Go back to using one List for everything in compose

# Conflicts:
#	Packages/ComposeUI/Package.swift
#	Packages/ComposeUI/Sources/ComposeUI/Controllers/ComposeController.swift

CHANGELOG-release.md

@@ -1,13 +1,3 @@
-## 2024.5
-Features/Improvements:
-- Improve gallery animations
-
-Bugfixes:
-- Handle right-to-left text in display names
-- Fix crash during gifv playback
-- iPadOS: Fix app becoming unresponsive when switching accounts
-- iPadOS/macOS: Fix Cmd+R shortcuts not working
-
 ## 2024.4
 This release introduces support for iOS 18, including a new sidebar/tab bar on iPad, as well as bugfixes and improvements.
 

CHANGELOG.md

@@ -1,33 +1,5 @@
 # Changelog
 
-## 2024.5 (141)
-Bugfixes:
-- Fix gallery controls being positioned incorrectly during dismiss animation on certain devices
-- Fix gallery controls being positioned incorrectly in landscape orientations
-
-## 2024.5 (139)
-Bugfixes:
-- Fix error decoding certain posts
-
-## 2024.5 (138)
-Bugfixes:
-- Fix potential crash when displaying certain attachments
-- Fix potential crash due to race condition when opening push notification in app
-- Fix misaligned text between profile field values/labels
-- Fix rate limited error message not including reset timestamp
-- iPadOS/macOS: Fix Cmd+R shortcut not working
-
-## 2024.5 (137)
-Features/Improvements:
-- Improve gallery presentation/dismissal transitions
-
-Bugfixes:
-- Account for bidirectional text in display names
-- Fix crash when playing back gifv
-- Fix gallery controls not hiding if video loading fails
-- iPadOS: Fix incorrect gallery dismiss animation on non-fullscreen windows
-- iPadOS: Fix hang when switching accounts
-
 ## 2024.4 (136)
 Features/Improvements:
 - Import image description when adding attachments from Photos if possible

NotificationExtension/NotificationService.swift

@@ -371,14 +371,13 @@ private struct HTMLCallbacks: HTMLConversionCallbacks {
         // Converting WebURL to URL is a small but non-trivial expense (since it works by
         // serializing the WebURL as a string and then having Foundation parse it again),
         // so, if available, use the system parser which doesn't require another round trip.
-        if #available(iOS 16.0, macOS 13.0, *),
-           let url = try? URL.ParseStrategy().parse(string) {
+        if let url = try? URL.ParseStrategy().parse(string) {
             url
         } else if let web = WebURL(string),
                   let url = URL(web) {
             url
         } else {
-            URL(string: string)
+            nil
         }
     }
     

Packages/ComposeUI/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "ComposeUI",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.
@@ -20,13 +20,14 @@ let package = Package(
         .package(path: "../InstanceFeatures"),
         .package(path: "../TuskerComponents"),
         .package(path: "../MatchedGeometryPresentation"),
+        .package(path: "../TuskerPreferences"),
     ],
     targets: [
         // Targets are the basic building blocks of a package. A target can define a module or a test suite.
         // Targets can depend on other targets in this package, and on products in packages this package depends on.
         .target(
             name: "ComposeUI",
-            dependencies: ["Pachyderm", "InstanceFeatures", "TuskerComponents", "MatchedGeometryPresentation"],
+            dependencies: ["Pachyderm", "InstanceFeatures", "TuskerComponents", "MatchedGeometryPresentation", "TuskerPreferences"],
             swiftSettings: [
                 .swiftLanguageMode(.v5)
             ]),

Packages/ComposeUI/Sources/ComposeUI/API/PostService.swift

@@ -11,7 +11,7 @@ import Pachyderm
 import UniformTypeIdentifiers
 
 @MainActor
-class PostService: ObservableObject {
+final class PostService: ObservableObject {
     private let mastodonController: ComposeMastodonContext
     private let config: ComposeUIConfig
     private let draft: Draft

Packages/ComposeUI/Sources/ComposeUI/CharacterCounter.swift

@@ -12,7 +12,7 @@ import InstanceFeatures
 public struct CharacterCounter {
     
     private static let linkDetector = try! NSDataDetector(types: NSTextCheckingResult.CheckingType.link.rawValue)
-    private static let mention = try! NSRegularExpression(pattern: "(@[a-z0-9_]+)(?:@[a-z0-9\\-\\.]+[a-z0-9]+)?", options: .caseInsensitive)
+    static let mention = try! NSRegularExpression(pattern: "(@[a-z0-9_]+)(?:@[a-z0-9\\-\\.]+[a-z0-9]+)?", options: .caseInsensitive)
     
     public static func count(text: String, for instanceFeatures: InstanceFeatures) -> Int {
         let mentionsRemoved = removeMentions(in: text)

Packages/ComposeUI/Sources/ComposeUI/ComposeInput.swift

@@ -8,6 +8,7 @@
 import Foundation
 import Combine
 import UIKit
+import SwiftUI
 
 protocol ComposeInput: AnyObject, ObservableObject {
     var toolbarElements: [ToolbarElement] { get }
@@ -27,3 +28,44 @@ enum ToolbarElement {
     case emojiPicker
     case formattingButtons
 }
+
+private struct FocusedComposeInput: FocusedValueKey {
+    typealias Value = any ComposeInput
+}
+
+extension FocusedValues {
+    var composeInput: (any ComposeInput)? {
+        get { self[FocusedComposeInput.self] }
+        set { self[FocusedComposeInput.self] = newValue }
+    }
+}
+
+@propertyWrapper
+final class MutableObservableBox<Value>: ObservableObject {
+    @Published var wrappedValue: Value
+    
+    init(wrappedValue: Value) {
+        self.wrappedValue = wrappedValue
+    }
+}
+
+private struct FocusedComposeInputBox: EnvironmentKey {
+    static let defaultValue: MutableObservableBox<(any ComposeInput)?> = .init(wrappedValue: nil)
+}
+
+extension EnvironmentValues {
+    var composeInputBox: MutableObservableBox<(any ComposeInput)?> {
+        get { self[FocusedComposeInputBox.self] }
+        set { self[FocusedComposeInputBox.self] = newValue }
+    }
+}
+
+struct FocusedInputModifier: ViewModifier {
+    @StateObject var box: MutableObservableBox<(any ComposeInput)?> = .init(wrappedValue: nil)
+    
+    func body(content: Content) -> some View {
+        content
+            .environment(\.composeInputBox, box)
+            .focusedValue(\.composeInput, box.wrappedValue)
+    }
+}

Packages/ComposeUI/Sources/ComposeUI/ComposeMastodonContext.swift

@@ -9,6 +9,7 @@ import Foundation
 import Pachyderm
 import InstanceFeatures
 import UserAccounts
+import SwiftUI
 
 public protocol ComposeMastodonContext {
     var accountInfo: UserAccountInfo? { get }
@@ -26,4 +27,6 @@ public protocol ComposeMastodonContext {
     func searchCachedHashtags(query: String) -> [Hashtag]
     
     func storeCreatedStatus(_ status: Status)
+    
+    func fetchStatus(id: String) -> (any StatusProtocol)?
 }

Packages/ComposeUI/Sources/ComposeUI/Controllers/AttachmentRowController.swift

@@ -156,7 +156,7 @@ class AttachmentRowController: ViewController {
                         Button(role: .destructive, action: controller.removeAttachment) {
                             Label("Delete", systemImage: "trash")
                         }
-                    } previewIfAvailable: {
+                    } preview: {
                         ControllerView(controller: { controller.thumbnailController })
                     }
                 
@@ -221,16 +221,3 @@ extension AttachmentRowController {
         case allowEntry, recognizingText
     }
 }
-
-private extension View {
-    @available(iOS, obsoleted: 16.0)
-    @available(visionOS 1.0, *)
-    @ViewBuilder
-    func contextMenu<M: View, P: View>(@ViewBuilder menuItems: () -> M, @ViewBuilder previewIfAvailable preview: () -> P) -> some View {
-        if #available(iOS 16.0, *) {
-            self.contextMenu(menuItems: menuItems, preview: preview)
-        } else {
-            self.contextMenu(menuItems: menuItems)
-        }
-    }
-}

Packages/ComposeUI/Sources/ComposeUI/Controllers/AttachmentThumbnailController.swift

@@ -181,7 +181,7 @@ extension EnvironmentValues {
     }
 }
 
-private struct GIFViewWrapper: UIViewRepresentable {
+struct GIFViewWrapper: UIViewRepresentable {
     typealias UIViewType = GIFImageView
 
     @State var controller: GIFController

Packages/ComposeUI/Sources/ComposeUI/Controllers/AttachmentsListController.swift

@@ -131,7 +131,6 @@ class AttachmentsListController: ViewController {
         @EnvironmentObject private var controller: AttachmentsListController
         @EnvironmentObject private var draft: Draft
         @Environment(\.colorScheme) private var colorScheme
-        @Environment(\.horizontalSizeClass) private var horizontalSizeClass
         
         var body: some View {
             attachmentsList
@@ -214,48 +213,10 @@ fileprivate extension View {
             self
         }
     }
-    
-    @available(iOS, obsoleted: 16.0)
-    @ViewBuilder
-    func sheetOrPopover(isPresented: Binding<Bool>, @ViewBuilder content: @escaping () -> some View) -> some View {
-        if #available(iOS 16.0, *) {
-            self.modifier(SheetOrPopover(isPresented: isPresented, view: content))
-        } else {
-            self.popover(isPresented: isPresented, content: content)
-        }
-    }
-    
-    @available(iOS, obsoleted: 16.0)
-    @ViewBuilder
-    func withSheetDetentsIfAvailable() -> some View {
-        if #available(iOS 16.0, *) {
-            self
-                .presentationDetents([.medium, .large])
-                .presentationDragIndicator(.visible)
-        } else {
-            self
-        }
-    }
-}
-
-@available(iOS 16.0, *)
-fileprivate struct SheetOrPopover<V: View>: ViewModifier {
-    @Binding var isPresented: Bool
-    @ViewBuilder let view: () -> V
-    
-    @Environment(\.horizontalSizeClass) var sizeClass
-    
-    func body(content: Content) -> some View {
-        if sizeClass == .compact {
-            content.sheet(isPresented: $isPresented, content: view)
-        } else {
-            content.popover(isPresented: $isPresented, content: view)
-        }
-    }
 }
 
 @available(visionOS 1.0, *)
-fileprivate struct AttachmentButtonLabelStyle: LabelStyle {
+struct AttachmentButtonLabelStyle: LabelStyle {
     func makeBody(configuration: Configuration) -> some View {
         DefaultLabelStyle().makeBody(configuration: configuration)
             .foregroundStyle(.white)

Packages/ComposeUI/Sources/ComposeUI/Controllers/ComposeController.swift

@@ -125,18 +125,22 @@ public final class ComposeController: ViewController {
         self.toolbarController = ToolbarController(parent: self)
         self.attachmentsListController = AttachmentsListController(parent: self)
         
-        if #available(iOS 16.0, *) {
-            NotificationCenter.default.addObserver(self, selector: #selector(currentInputModeChanged), name: UITextInputMode.currentInputModeDidChangeNotification, object: nil)
-        }
+        NotificationCenter.default.addObserver(self, selector: #selector(currentInputModeChanged), name: UITextInputMode.currentInputModeDidChangeNotification, object: nil)
         NotificationCenter.default.addObserver(self, selector: #selector(managedObjectsDidChange), name: .NSManagedObjectContextObjectsDidChange, object: DraftsPersistentContainer.shared.viewContext)
     }
     
     public var view: some View {
-        ComposeView(poster: poster)
-            .environment(\.managedObjectContext, DraftsPersistentContainer.shared.viewContext)
-            .environmentObject(draft)
-            .environmentObject(mastodonController.instanceFeatures)
-            .environment(\.composeUIConfig, config)
+        if Preferences.shared.hasFeatureFlag(.composeRewrite) {
+            ComposeUI.ComposeView(draft: draft, mastodonController: mastodonController)
+                .environment(\.currentAccount, currentAccount)
+                .environment(\.composeUIConfig, config)
+        } else {
+            ComposeView(poster: poster)
+                .environment(\.managedObjectContext, DraftsPersistentContainer.shared.viewContext)
+                .environmentObject(draft)
+                .environmentObject(mastodonController.instanceFeatures)
+                .environment(\.composeUIConfig, config)
+        }
     }
     
     @MainActor
@@ -324,10 +328,6 @@ public final class ComposeController: ViewController {
                         ControllerView(controller: { controller.toolbarController })
                         #endif
                     }
-                    #if !os(visionOS)
-                    // on iPadOS15, the toolbar ends up below the keyboard's toolbar without this
-                    .padding(.bottom, keyboardInset)
-                    #endif
                     .transition(.move(edge: .bottom))
                 }
             }
@@ -436,7 +436,7 @@ public final class ComposeController: ViewController {
             }
             .listStyle(.plain)
             #if !os(visionOS)
-            .scrollDismissesKeyboardInteractivelyIfAvailable()
+            .scrollDismissesKeyboard(.interactively)
             #endif
             .disabled(controller.isPosting)
         }
@@ -487,31 +487,6 @@ public final class ComposeController: ViewController {
             .keyboardShortcut(.return, modifiers: .command)
             .disabled(!controller.postButtonEnabled)
         }
-        
-        #if !os(visionOS)
-        @available(iOS, obsoleted: 16.0)
-        private var keyboardInset: CGFloat {
-            if #unavailable(iOS 16.0),
-               UIDevice.current.userInterfaceIdiom == .pad,
-               keyboardReader.isVisible {
-                return ToolbarController.height
-            } else {
-                return 0
-            }
-        }
-        #endif
-    }
-}
-
-private extension View {
-    @available(iOS, obsoleted: 16.0)
-    @ViewBuilder
-    func scrollDismissesKeyboardInteractivelyIfAvailable() -> some View {
-        if #available(iOS 16.0, *) {
-            self.scrollDismissesKeyboard(.interactively)
-        } else {
-            self
-        }
     }
 }
 

Packages/ComposeUI/Sources/ComposeUI/Controllers/FocusedAttachmentController.swift

@@ -51,14 +51,11 @@ class FocusedAttachmentController: ViewController {
                         .onAppear {
                             player.play()
                         }
-                } else if #available(iOS 16.0, *) {
+                } else {
                     ZoomableScrollView {
                         attachmentView
                             .matchedGeometryDestination(id: attachment.id)
                     }
-                } else {
-                    attachmentView
-                        .matchedGeometryDestination(id: attachment.id)
                 }
                 
                 Spacer(minLength: 0)

Packages/ComposeUI/Sources/ComposeUI/Controllers/PlaceholderController.swift

@@ -17,7 +17,7 @@ final class PlaceholderController: ViewController, PlaceholderViewProvider {
            Date().formatted(date: .numeric, time: .omitted).starts(with: "3") {
             Text("Happy π day!")
         } else if components.month == 4 && components.day == 1 {
-            Text("April Fool's!").rotationEffect(.radians(.pi), anchor: .center)
+            Text("April Fool’s!").rotationEffect(.radians(.pi), anchor: .center)
         } else if components.month == 9 && components.day == 5 {
             // https://weirder.earth/@noracodes/109276419847254552
             // https://retrocomputing.stackexchange.com/questions/14763/what-warning-was-given-on-attempting-to-post-to-usenet-circa-1990
@@ -31,7 +31,7 @@ final class PlaceholderController: ViewController, PlaceholderViewProvider {
                 Text("Any questions?")
             }
         } else {
-            Text("What's on your mind?")
+            Text("What’s on your mind?")
         }
     }
     
@@ -41,7 +41,7 @@ final class PlaceholderController: ViewController, PlaceholderViewProvider {
 }
 
 // exists to provide access to the type alias since the @State property needs it to be explicit
-private protocol PlaceholderViewProvider {
+protocol PlaceholderViewProvider {
     associatedtype PlaceholderView: View
     @ViewBuilder
     static func makePlaceholderView() -> PlaceholderView

Packages/ComposeUI/Sources/ComposeUI/Controllers/PollController.swift

@@ -96,7 +96,7 @@ class PollController: ViewController {
                     .onMove(perform: controller.moveOptions)
                 }
                 .listStyle(.plain)
-                .scrollDisabledIfAvailable(true)
+                .scrollDisabled(true)
                 .frame(height: 44 * CGFloat(poll.options.count))
                 
                 Button(action: controller.addOption) {

Packages/ComposeUI/Sources/ComposeUI/Controllers/ToolbarController.swift

@@ -66,7 +66,7 @@ class ToolbarController: ViewController {
                             }
                     })
             }
-            .scrollDisabledIfAvailable(realWidth ?? 0 <= minWidth ?? 0)
+            .scrollDisabled(realWidth ?? 0 <= minWidth ?? 0)
             .frame(height: ToolbarController.height)
             .frame(maxWidth: .infinity)
             .background(.regularMaterial, ignoresSafeAreaEdges: [.bottom, .leading, .trailing])
@@ -122,8 +122,7 @@ class ToolbarController: ViewController {
                 
                 Spacer()
                 
-                if #available(iOS 16.0, *),
-                   composeController.mastodonController.instanceFeatures.createStatusWithLanguage {
+                if composeController.mastodonController.instanceFeatures.createStatusWithLanguage {
                     LanguagePicker(draftLanguage: $draft.language, hasChangedSelection: $composeController.hasChangedLanguageSelection)
                 }
             }

Packages/ComposeUI/Sources/ComposeUI/Environment.swift

@@ -0,0 +1,49 @@
+//
+//  Environment.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/10/24.
+//
+
+import SwiftUI
+import Pachyderm
+
+//@propertyWrapper
+//struct RequiredEnvironment<Value>: DynamicProperty {
+//    private let keyPath: KeyPath<EnvironmentValues, Value?>
+//    @Environment private var value: Value?
+//    
+//    init(_ keyPath: KeyPath<EnvironmentValues, Value?>) {
+//        self.keyPath = keyPath
+//        self._value = Environment(keyPath)
+//    }
+//    
+//    var wrappedValue: Value {
+//        guard let value else {
+//            preconditionFailure("Missing required environment value for \(keyPath)")
+//        }
+//        return value
+//    }
+//}
+
+private struct ComposeMastodonContextKey: EnvironmentKey {
+    static let defaultValue: (any ComposeMastodonContext)? = nil
+}
+
+extension EnvironmentValues {
+    var mastodonController: (any ComposeMastodonContext)? {
+        get { self[ComposeMastodonContextKey.self] }
+        set { self[ComposeMastodonContextKey.self] = newValue }
+    }
+}
+
+private struct CurrentAccountKey: EnvironmentKey {
+    static let defaultValue: (any AccountProtocol)? = nil
+}
+
+extension EnvironmentValues {
+    var currentAccount: (any AccountProtocol)? {
+        get { self[CurrentAccountKey.self] }
+        set { self[CurrentAccountKey.self] = newValue }
+    }
+}

Packages/ComposeUI/Sources/ComposeUI/KeyboardReader.swift

@@ -10,9 +10,7 @@
 import UIKit
 import Combine
 
-@available(iOS, obsoleted: 16.0)
 class KeyboardReader: ObservableObject {
-//    @Published var isVisible = false
     @Published var keyboardHeight: CGFloat = 0
     
     var isVisible: Bool {
@@ -27,14 +25,12 @@ class KeyboardReader: ObservableObject {
     
     @objc func willShow(_ notification: Foundation.Notification) {
         let endFrame = notification.userInfo![UIResponder.keyboardFrameEndUserInfoKey] as! CGRect
-//        isVisible = endFrame.height > 72
         keyboardHeight = endFrame.height
     }
     
     @objc func willHide() {
         // sometimes willHide is called during a SwiftUI view update
         DispatchQueue.main.async {
-//            self.isVisible = false
             self.keyboardHeight = 0
         }
     }

Packages/ComposeUI/Sources/ComposeUI/Model/StatusFormat.swift

@@ -9,9 +9,13 @@
 import UIKit
 import Pachyderm
 
-enum StatusFormat: Int, CaseIterable {
+enum StatusFormat: Int, CaseIterable, Identifiable {
     case bold, italics, strikethrough, code
     
+    var id: some Hashable {
+        rawValue
+    }
+    
     func insertionResult(for contentType: StatusContentType) -> FormatInsertionResult? {
         switch contentType {
         case .plain:

Packages/ComposeUI/Sources/ComposeUI/Preferences.swift

@@ -0,0 +1,11 @@
+//
+//  Preferences.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/10/24.
+//
+
+import Foundation
+import TuskerPreferences
+
+typealias Preferences = TuskerPreferences.Preferences

Packages/ComposeUI/Sources/ComposeUI/View+ForwardsCompat.swift

@@ -1,26 +0,0 @@
-//
-//  View+ForwardsCompat.swift
-//  ComposeUI
-//
-//  Created by Shadowfacts on 3/25/23.
-//
-
-import SwiftUI
-
-extension View {
-    #if os(visionOS)
-    func scrollDisabledIfAvailable(_ disabled: Bool) -> some View {
-        self.scrollDisabled(disabled)
-    }
-    #else
-    @available(iOS, obsoleted: 16.0)
-    @ViewBuilder
-    func scrollDisabledIfAvailable(_ disabled: Bool) -> some View {
-        if #available(iOS 16.0, *) {
-            self.scrollDisabled(disabled)
-        } else {
-            self
-        }
-    }
-    #endif
-}

Packages/ComposeUI/Sources/ComposeUI/ViewController.swift

@@ -11,6 +11,7 @@ import Combine
 public protocol ViewController: ObservableObject {
     associatedtype ContentView: View
     
+    @MainActor
     @ViewBuilder
     var view: ContentView { get }
 }

Packages/ComposeUI/Sources/ComposeUI/Views/AttachmentRowView.swift

@@ -0,0 +1,182 @@
+//
+//  AttachmentRowView.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/18/24.
+//
+
+import SwiftUI
+import InstanceFeatures
+import Vision
+
+struct AttachmentRowView: View {
+    @ObservedObject var attachment: DraftAttachment
+    @State private var isRecognizingText = false
+    @State private var textRecognitionError: (any Error)?
+    
+    private var thumbnailSize: CGFloat {
+        #if os(visionOS)
+        120
+        #else
+        80
+        #endif
+    }
+    
+    var body: some View {
+        HStack(alignment: .center, spacing: 4) {
+            thumbnailView
+            
+            descriptionView
+        }
+        .alertWithData("Text Recognition Failed", data: $textRecognitionError) { _ in
+            Button("OK") {}
+        } message: { error in
+            Text(error.localizedDescription)
+        }
+    }
+    
+    // TODO: attachments missing descriptions feature
+    
+    private var thumbnailView: some View {
+        AttachmentThumbnailView(attachment: attachment)
+            .clipShape(RoundedRectangle(cornerRadius: 8))
+            .frame(width: thumbnailSize, height: thumbnailSize)
+            .contextMenu {
+                EditDrawingButton(attachment: attachment)
+                RecognizeTextButton(attachment: attachment, isRecognizingText: $isRecognizingText, error: $textRecognitionError)
+                DeleteButton(attachment: attachment)
+            } preview: {
+                // TODO: need to fix flash of preview changing size
+                AttachmentThumbnailView(attachment: attachment)
+            }
+    }
+    
+    @ViewBuilder
+    private var descriptionView: some View {
+        if isRecognizingText {
+            ProgressView()
+                .progressViewStyle(.circular)
+        } else {
+            InlineAttachmentDescriptionView(attachment: attachment, minHeight: thumbnailSize)
+        }
+    }
+}
+
+private struct EditDrawingButton: View {
+    @ObservedObject var attachment: DraftAttachment
+    @Environment(\.composeUIConfig.presentDrawing) private var presentDrawing
+    
+    var body: some View {
+        if attachment.drawingData != nil {
+            Button(action: editDrawing) {
+                Label("Edit Drawing", systemImage: "hand.draw")
+            }
+        }
+    }
+    
+    private func editDrawing() {
+        if case .drawing(let drawing) = attachment.data {
+            presentDrawing?(drawing) {
+                attachment.drawing = $0
+            }
+        }
+    }
+}
+
+private struct RecognizeTextButton: View {
+    @ObservedObject var attachment: DraftAttachment
+    @Binding var isRecognizingText: Bool
+    @Binding var error: (any Error)?
+    @EnvironmentObject private var instanceFeatures: InstanceFeatures
+    
+    var body: some View {
+        if attachment.type == .image {
+            Button {
+                Task {
+                    await recognizeText()
+                }
+            } label: {
+                Label("Recognize Text", systemImage: "doc.text.viewfinder")
+            }
+        }
+    }
+    
+    private func recognizeText() async {
+        isRecognizingText = true
+        defer { isRecognizingText = false }
+        
+        do {
+            let data = try await getAttachmentData()
+            let observations = try await runRecognizeTextRequest(data: data)
+            if let observations {
+                var text = ""
+                for observation in observations {
+                    let result = observation.topCandidates(1).first!
+                    text.append(result.string)
+                    text.append("\n")
+                }
+                self.attachment.attachmentDescription = text
+            }
+        } catch let error as NSError where error.domain == VNErrorDomain && error.code == 1 {
+            // The perform call throws an error with code 1 if the request is cancelled, which we don't want to show an alert for.
+            return
+        } catch {
+            self.error = error
+        }
+    }
+    
+    private func getAttachmentData() async throws -> Data {
+        return try await withCheckedThrowingContinuation { continuation in
+            attachment.getData(features: instanceFeatures) { result in
+                switch result {
+                case .success(let (data, _)):
+                    continuation.resume(returning: data)
+                case .failure(let error):
+                    continuation.resume(throwing: error)
+                }
+            }
+        }
+    }
+    
+    private func runRecognizeTextRequest(data: Data) async throws -> [VNRecognizedTextObservation]? {
+        return try await withCheckedThrowingContinuation { continuation in
+            let handler = VNImageRequestHandler(data: data)
+            let request = VNRecognizeTextRequest { request, error in
+                if let error {
+                    continuation.resume(throwing: error)
+                } else {
+                    continuation.resume(returning: request.results as? [VNRecognizedTextObservation])
+                }
+            }
+            request.recognitionLevel = .accurate
+            request.usesLanguageCorrection = true
+            DispatchQueue.global(qos: .userInitiated).async {
+                try? handler.perform([request])
+            }
+        }
+    }
+}
+
+private struct DeleteButton: View {
+    let attachment: DraftAttachment
+    
+    var body: some View {
+        Button(role: .destructive, action: removeAttachment) {
+            Label("Delete", systemImage: "trash")
+        }
+    }
+    
+    private func removeAttachment() {
+        let draft = attachment.draft
+        var array = draft.draftAttachments
+        guard let index = array.firstIndex(of: attachment) else {
+            return
+        }
+        array.remove(at: index)
+        draft.attachments = NSMutableOrderedSet(array: array)
+    }
+}
+
+//#Preview {
+//    AttachmentRowView()
+//}

Packages/ComposeUI/Sources/ComposeUI/Views/AttachmentThumbnailView.swift

@@ -0,0 +1,114 @@
+//
+//  AttachmentThumbnailView.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 10/14/24.
+//
+
+import SwiftUI
+import TuskerComponents
+import AVFoundation
+import Photos
+
+struct AttachmentThumbnailView: View {
+    let attachment: DraftAttachment
+    let contentMode: ContentMode = .fit
+    @State private var mode: Mode = .empty
+    @EnvironmentObject private var composeController: ComposeController
+    
+    var body: some View {
+        switch mode {
+        case .empty:
+            Image(systemName: "photo")
+                .task {
+                    await loadThumbnail()
+                }
+        case .image(let image):
+            Image(uiImage: image)
+                .resizable()
+                .aspectRatio(contentMode: contentMode)
+        case .gifController(let controller):
+            GIFViewWrapper(controller: controller)
+        }
+    }
+    
+    private func loadThumbnail() async {
+        switch attachment.data {
+        case .editing(_, let kind, let url):
+            switch kind {
+            case .image:
+                if let image = await composeController.fetchAttachment(url) {
+                    self.mode = .image(image)
+                }
+                
+            case .video, .gifv:
+                await loadVideoThumbnail(url: url)
+                
+            case .audio, .unknown:
+                break
+            }
+            
+        case .asset(let id):
+            guard let asset = PHAsset.fetchAssets(withLocalIdentifiers: [id], options: nil).firstObject else {
+                return
+            }
+            let isGIF = PHAssetResource.assetResources(for: asset).contains {
+                $0.uniformTypeIdentifier == UTType.gif.identifier
+            }
+            if isGIF {
+                PHImageManager.default().requestImageDataAndOrientation(for: asset, options: nil) { data, typeIdentifier, orientation, info in
+                    guard let data else { return }
+                    if typeIdentifier == UTType.gif.identifier {
+                        self.mode = .gifController(GIFController(gifData: data))
+                    } else if let image = UIImage(data: data) {
+                        self.mode = .image(image)
+                    }
+                }
+            } else {
+                let size = CGSize(width: 80, height: 80)
+                PHImageManager.default().requestImage(for: asset, targetSize: size, contentMode: .aspectFill, options: nil) { image, _ in
+                    if let image {
+                        self.mode = .image(image)
+                    }
+                }
+            }
+            
+        case .drawing(let drawing):
+            self.mode = .image(drawing.imageInLightMode(from: drawing.bounds))
+            
+        case .file(let url, let type):
+            if type.conforms(to: .movie) {
+                await loadVideoThumbnail(url: url)
+            } else if let data = try? Data(contentsOf: url) {
+                if type == .gif {
+                    self.mode = .gifController(GIFController(gifData: data))
+                } else if type.conforms(to: .image) {
+                    if let image = UIImage(data: data),
+                       // using prepareThumbnail on images from PHPicker results in extremely high memory usage,
+                       // crashing share extension. see FB12186346
+                       let prepared = await image.byPreparingForDisplay() {
+                        self.mode = .image(prepared)
+                    }
+                }
+            }
+            
+        case .none:
+            break
+        }
+    }
+    
+    private func loadVideoThumbnail(url: URL) async {
+        let asset = AVURLAsset(url: url)
+        let imageGenerator = AVAssetImageGenerator(asset: asset)
+        imageGenerator.appliesPreferredTrackTransform = true
+        if let (cgImage, _) = try? await imageGenerator.image(at: .zero) {
+            self.mode = .image(UIImage(cgImage: cgImage))
+        }
+    }
+    
+    enum Mode {
+        case empty
+        case image(UIImage)
+        case gifController(GIFController)
+    }
+}

Packages/ComposeUI/Sources/ComposeUI/Views/AttachmentsListSection.swift

@@ -0,0 +1,182 @@
+//
+//  AttachmentsListSection.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 10/14/24.
+//
+
+import SwiftUI
+import InstanceFeatures
+import PencilKit
+
+struct AttachmentsListSection: View {
+    @ObservedObject var draft: Draft
+    @ObservedObject var instanceFeatures: InstanceFeatures
+    @Environment(\.canAddAttachment) private var canAddAttachment
+    
+    var body: some View {
+        attachmentRows
+        
+        buttons
+            .foregroundStyle(.tint)
+            #if os(visionOS)
+            .buttonStyle(.bordered)
+            .labelStyle(AttachmentButtonLabelStyle())
+            #endif
+    }
+    
+    private var attachmentRows: some View {
+        ForEach(draft.draftAttachments) { attachment in
+            AttachmentRowView(attachment: attachment)
+        }
+        .onMove(perform: moveAttachments)
+        .onDelete(perform: deleteAttachments)
+        .onInsert(of: DraftAttachment.readableTypeIdentifiersForItemProvider) { offset, providers in
+            Self.insertAttachments(in: draft, at: offset, itemProviders: providers)
+        }
+    }
+    
+    @ViewBuilder
+    private var buttons: some View {
+        AddPhotoButton(addAttachments: self.addAttachments)
+        
+        AddDrawingButton(draft: draft)
+        
+        TogglePollButton(draft: draft)
+    }
+    
+    static func insertAttachments(in draft: Draft, at index: Int, itemProviders: [NSItemProvider]) {
+        for provider in itemProviders where provider.canLoadObject(ofClass: DraftAttachment.self) {
+            provider.loadObject(ofClass: DraftAttachment.self) { object, error in
+                guard let attachment = object as? DraftAttachment else { return }
+                DispatchQueue.main.async {
+                    DraftsPersistentContainer.shared.viewContext.insert(attachment)
+                    attachment.draft = draft
+                    draft.attachments.add(attachment)
+                }
+            }
+        }
+    }
+    
+    private func addAttachments(itemProviders: [NSItemProvider]) {
+        Self.insertAttachments(in: draft, at: draft.attachments.count, itemProviders: itemProviders)
+    }
+    
+    private func moveAttachments(from source: IndexSet, to destination: Int) {
+        // just using moveObjects(at:to:) on the draft.attachments NSMutableOrderedSet
+        // results in the order switching back to the previous order and then to the correct one
+        // on the subsequent 2 view updates. creating a new set with the proper order doesn't have that problem
+        var array = draft.draftAttachments
+        array.move(fromOffsets: source, toOffset: destination)
+        draft.attachments = NSMutableOrderedSet(array: array)
+    }
+    
+    private func deleteAttachments(at indices: IndexSet) {
+        var array = draft.draftAttachments
+        array.remove(atOffsets: indices)
+        draft.attachments = NSMutableOrderedSet(array: array)
+    }
+
+}
+
+private struct AddPhotoButton: View {
+    let addAttachments: ([NSItemProvider]) -> Void
+    @Environment(\.composeUIConfig.presentAssetPicker) private var presentAssetPicker
+    
+    var body: some View {
+        if let presentAssetPicker {
+            Button("Add photo or video", systemImage: "photo") {
+                presentAssetPicker { results in
+                    addAttachments(results.map(\.itemProvider))
+                }
+            }
+        }
+    }
+}
+
+private struct AddDrawingButton: View {
+    let draft: Draft
+    @Environment(\.composeUIConfig.presentDrawing) private var presentDrawing
+    
+    var body: some View {
+        if let presentDrawing {
+            Button("Add drawing", systemImage: "hand.draw") {
+                presentDrawing(PKDrawing()) { drawing in
+                    let attachment = DraftAttachment(context: DraftsPersistentContainer.shared.viewContext)
+                    attachment.id = UUID()
+                    attachment.drawing = drawing
+                    attachment.draft = self.draft
+                    self.draft.attachments.add(attachment)
+                }
+            }
+        }
+    }
+}
+
+private struct TogglePollButton: View {
+    @ObservedObject var draft: Draft
+    
+    var body: some View {
+        Button(draft.poll == nil ? "Add a poll" : "Remove poll", systemImage: "chart.bar.doc.horizontal") {
+            withAnimation {
+                draft.poll = draft.poll == nil ? Poll(context: DraftsPersistentContainer.shared.viewContext) : nil
+            }
+        }
+        .disabled(draft.attachments.count > 0)
+    }
+}
+
+struct AddAttachmentConditionsModifier: ViewModifier {
+    @ObservedObject var draft: Draft
+    @ObservedObject var instanceFeatures: InstanceFeatures
+    
+    private var canAddAttachment: Bool {
+        if instanceFeatures.mastodonAttachmentRestrictions {
+            return draft.attachments.count < 4
+                && draft.draftAttachments.allSatisfy { $0.type == .image }
+                && draft.poll == nil
+        } else {
+            return true
+        }
+    }
+
+    func body(content: Content) -> some View {
+        content
+            .environment(\.canAddAttachment, canAddAttachment)
+    }
+}
+
+private struct CanAddAttachmentKey: EnvironmentKey {
+    static let defaultValue = false
+}
+
+extension EnvironmentValues {
+    var canAddAttachment: Bool {
+        get { self[CanAddAttachmentKey.self] }
+        set { self[CanAddAttachmentKey.self] = newValue }
+    }
+}
+
+struct DropAttachmentModifier: ViewModifier {
+    let draft: Draft
+    @Environment(\.canAddAttachment) private var canAddAttachment
+    
+    func body(content: Content) -> some View {
+        content
+            .onDrop(of: DraftAttachment.readableTypeIdentifiersForItemProvider, delegate: AttachmentDropDelegate(draft: draft, canAddAttachment: canAddAttachment))
+    }
+}
+
+private struct AttachmentDropDelegate: DropDelegate {
+    let draft: Draft
+    let canAddAttachment: Bool
+    
+    func validateDrop(info: DropInfo) -> Bool {
+        canAddAttachment
+    }
+    
+    func performDrop(info: DropInfo) -> Bool {
+        AttachmentsListSection.insertAttachments(in: draft, at: draft.attachments.count, itemProviders: info.itemProviders(for: DraftAttachment.readableTypeIdentifiersForItemProvider))
+        return true
+    }
+}

Packages/ComposeUI/Sources/ComposeUI/Views/ComposeToolbarView.swift

@@ -0,0 +1,272 @@
+//
+//  ComposeToolbarView.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/10/24.
+//
+
+import SwiftUI
+import TuskerComponents
+import InstanceFeatures
+import Pachyderm
+import TuskerPreferences
+
+struct ComposeToolbarView: View {
+    static let height: CGFloat = 44
+    
+    @ObservedObject var draft: Draft
+    let mastodonController: any ComposeMastodonContext
+    @FocusState.Binding var focusedField: FocusableField?
+    
+    var body: some View {
+        #if os(visionOS)
+        buttons
+        #else
+        ToolbarScrollView {
+            buttons
+                .padding(.horizontal, 16)
+        }
+        .frame(height: Self.height)
+        .background(.regularMaterial, ignoresSafeAreaEdges: [.bottom, .leading, .trailing])
+        .overlay(alignment: .top) {
+            Divider()
+                .ignoresSafeArea(edges: [.leading, .trailing])
+        }
+        #endif
+    }
+    
+    private var buttons: some View {
+        HStack(spacing: 0) {
+            ContentWarningButton(enabled: $draft.contentWarningEnabled, focusedField: $focusedField)
+            
+            VisibilityButton(draft: draft, instanceFeatures: mastodonController.instanceFeatures)
+            
+            LocalOnlyButton(enabled: $draft.localOnly, mastodonController: mastodonController)
+            
+            InsertEmojiButton()
+            
+            FormatButtons()
+            
+            Spacer()
+            
+            LangaugeButton(draft: draft, instanceFeatures: mastodonController.instanceFeatures)
+        }
+    }
+}
+
+#if !os(visionOS)
+private struct ToolbarScrollView<Content: View>: View {
+    @ViewBuilder let content: Content
+    @State private var minWidth: CGFloat?
+    @State private var realWidth: CGFloat?
+    
+    var body: some View {
+        ScrollView(.horizontal, showsIndicators: false) {
+            content
+                .frame(minWidth: minWidth)
+                .background {
+                    GeometryReader { proxy in
+                        Color.clear
+                            .preference(key: ToolbarWidthPrefKey.self, value: proxy.size.width)
+                            .onPreferenceChange(ToolbarWidthPrefKey.self) {
+                                realWidth = $0
+                            }
+                    }
+                }
+        }
+        .scrollDisabled(realWidth ?? 0 <= minWidth ?? 0)
+        .frame(maxWidth: .infinity)
+        .background {
+            GeometryReader { proxy in
+                Color.clear
+                    .preference(key: ToolbarWidthPrefKey.self, value: proxy.size.width)
+                    .onPreferenceChange(ToolbarWidthPrefKey.self) {
+                        minWidth = $0
+                    }
+            }
+        }
+    }
+}
+#endif
+
+private struct ToolbarWidthPrefKey: SwiftUI.PreferenceKey {
+    static var defaultValue: CGFloat? = nil
+    static func reduce(value: inout CGFloat?, nextValue: () -> CGFloat?) {
+        value = value ?? nextValue()
+    }
+}
+
+private struct ContentWarningButton: View {
+    @Binding var enabled: Bool
+    @FocusState.Binding var focusedField: FocusableField?
+    
+    var body: some View {
+        Button("CW", action: toggleContentWarning)
+            .accessibilityLabel(enabled ? "Remove content warning" : "Add content warning")
+            .padding(5)
+            .hoverEffect()
+    }
+    
+    private func toggleContentWarning() {
+        enabled.toggle()
+        if enabled {
+            focusedField = .contentWarning
+        }
+    }
+}
+
+private struct VisibilityButton: View {
+    @ObservedObject var draft: Draft
+    @ObservedObject var instanceFeatures: InstanceFeatures
+    
+    private var visibilityBinding: Binding<Pachyderm.Visibility> {
+        // On instances that conflate visibliity and local only, we still show two separate controls but don't allow
+        // changing the visibility when local-only.
+        if draft.localOnly,
+           instanceFeatures.localOnlyPostsVisibility {
+            return .constant(.public)
+        } else {
+            return $draft.visibility
+        }
+    }
+    
+    private var visibilityOptions: [MenuPicker<Pachyderm.Visibility>.Option] {
+        let visibilities: [Pachyderm.Visibility]
+        if !instanceFeatures.composeDirectStatuses {
+            visibilities = [.public, .unlisted, .private]
+        } else {
+            visibilities = Pachyderm.Visibility.allCases
+        }
+        return visibilities.map { vis in
+            .init(value: vis, title: vis.displayName, subtitle: vis.subtitle, image: UIImage(systemName: vis.unfilledImageName), accessibilityLabel: "Visibility: \(vis.displayName)")
+        }
+    }
+    
+    var body: some View {
+        MenuPicker(selection: visibilityBinding, options: visibilityOptions, buttonStyle: .iconOnly)
+            #if !targetEnvironment(macCatalyst) && !os(visionOS)
+            // the button has a bunch of extra space by default, but combined with what we add it's too much
+            .padding(.horizontal, -8)
+            #endif
+            .disabled(draft.editedStatusID != nil)
+            .disabled(instanceFeatures.localOnlyPostsVisibility && draft.localOnly)
+    }
+}
+
+private struct LocalOnlyButton: View {
+    @Binding var enabled: Bool
+    var mastodonController: any ComposeMastodonContext
+    @ObservedObject private var instanceFeatures: InstanceFeatures
+    
+    init(enabled: Binding<Bool>, mastodonController: any ComposeMastodonContext) {
+        self._enabled = enabled
+        self.mastodonController = mastodonController
+        self.instanceFeatures = mastodonController.instanceFeatures
+    }
+    
+    private var options: [MenuPicker<Bool>.Option] {
+        let domain = mastodonController.accountInfo!.instanceURL.host!
+        return [
+            .init(value: true, title: "Local-only", subtitle: "Only \(domain)", image: UIImage(named: "link.broken")),
+            .init(value: false, title: "Federated", image: UIImage(systemName: "link")),
+        ]
+    }
+    
+    var body: some View {
+        if mastodonController.instanceFeatures.localOnlyPosts {
+            MenuPicker(selection: $enabled, options: options, buttonStyle: .iconOnly)
+        }
+    }
+}
+
+private struct InsertEmojiButton: View {
+    @FocusedValue(\.composeInput) private var input
+    @ScaledMetric(relativeTo: .body) private var imageSize: CGFloat = 22
+    
+    var body: some View {
+        if input?.toolbarElements.contains(.emojiPicker) == true {
+            Button(action: beginAutocompletingEmoji) {
+                Label("Insert custom emoji", systemImage: "face.smiling")
+            }
+            .labelStyle(.iconOnly)
+            .font(.system(size: imageSize))
+            .padding(5)
+            .hoverEffect()
+            .transition(.opacity.animation(.linear(duration: 0.2)))
+        }
+    }
+    
+    private func beginAutocompletingEmoji() {
+        input?.beginAutocompletingEmoji()
+    }
+}
+
+private struct FormatButtons: View {
+    @FocusedValue(\.composeInput) private var input
+    @PreferenceObserving(\.$statusContentType) private var contentType
+    
+    var body: some View {
+        if let input,
+           input.toolbarElements.contains(.formattingButtons),
+           contentType != .plain {
+            
+            Spacer()
+            ForEach(StatusFormat.allCases) { format in
+                FormatButton(format: format, input: input)
+            }
+        }
+    }
+}
+
+private struct FormatButton: View {
+    let format: StatusFormat
+    let input: any ComposeInput
+    @ScaledMetric(relativeTo: .body) private var imageSize: CGFloat = 22
+    
+    var body: some View {
+        Button(action: applyFormat) {
+            Image(systemName: format.imageName)
+                .font(.system(size: imageSize))
+        }
+        .accessibilityLabel(format.accessibilityLabel)
+        .padding(5)
+        .hoverEffect()
+        .transition(.opacity.animation(.linear(duration: 0.2)))
+    }
+    
+    private func applyFormat() {
+        input.applyFormat(format)
+    }
+}
+
+private struct LangaugeButton: View {
+    @ObservedObject var draft: Draft
+    @ObservedObject var instanceFeatures: InstanceFeatures
+    @FocusedValue(\.composeInput) private var input
+    @State private var hasChanged = false
+    
+    var body: some View {
+        if instanceFeatures.createStatusWithLanguage {
+            LanguagePicker(draftLanguage: $draft.language, hasChangedSelection: $hasChanged)
+                .onReceive(NotificationCenter.default.publisher(for: UITextInputMode.currentInputModeDidChangeNotification), perform: currentInputModeChanged)
+                .onChange(of: draft.id) { _ in
+                    hasChanged = false
+                }
+        }
+    }
+    
+    @available(iOS 16.0, *)
+    private func currentInputModeChanged(_ notification: Foundation.Notification) {
+        guard !hasChanged,
+              !draft.hasContent,
+              let mode = input?.textInputMode,
+              let code = LanguagePicker.codeFromInputMode(mode) else {
+            return
+        }
+        draft.language = code.identifier
+    }
+}
+
+//#Preview {
+//    ComposeToolbarView()
+//}

Packages/ComposeUI/Sources/ComposeUI/Views/ComposeView.swift

@@ -0,0 +1,235 @@
+//
+//  ComposeView.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/10/24.
+//
+
+import SwiftUI
+
+struct ComposeView: View {
+    @ObservedObject var draft: Draft
+    let mastodonController: any ComposeMastodonContext
+    @State private var poster: PostService? = nil
+    @FocusState private var focusedField: FocusableField?
+    @EnvironmentObject private var controller: ComposeController
+    
+    var body: some View {
+        NavigationStack {
+            navigationRoot
+        }
+    }
+    
+    private var navigationRoot: some View {
+        ZStack {
+            List {
+                listContent
+            }
+            .listStyle(.plain)
+            .scrollDismissesKeyboard(.interactively)
+            #if !os(visionOS) && !targetEnvironment(macCatalyst)
+            .modifier(ToolbarSafeAreaInsetModifier())
+            #endif
+        }
+        .overlay(alignment: .top) {
+            if let poster {
+                PostProgressView(poster: poster)
+                    .frame(alignment: .top)
+            }
+        }
+        #if !os(visionOS)
+        .overlay(alignment: .bottom, content: {
+            // TODO: during ducking animation, toolbar should move off the botto edge
+            // This needs to be in an overlay, ignoring the keyboard safe area
+            // doesn't work with the safeAreaInset modifier.
+            toolbarView
+                .frame(maxHeight: .infinity, alignment: .bottom)
+                .ignoresSafeArea(.keyboard)
+        })
+        #endif
+        // Have these after the overlays so they barely work instead of not working at all. FB11790805
+        .modifier(DropAttachmentModifier(draft: draft))
+        .modifier(AddAttachmentConditionsModifier(draft: draft, instanceFeatures: mastodonController.instanceFeatures))
+        .modifier(NavigationTitleModifier(draft: draft, mastodonController: mastodonController))
+        .navigationBarTitleDisplayMode(.inline)
+        .toolbar {
+            ToolbarActions(draft: draft, controller: controller)
+            #if os(visionOS)
+            ToolbarItem(placement: .bottomOrnament) {
+                toolbarView
+            }
+            #endif
+        }
+    }
+    
+    private var toolbarView: some View {
+        ComposeToolbarView(draft: draft, mastodonController: mastodonController, focusedField: $focusedField)
+    }
+    
+    @ViewBuilder
+    private var listContent: some View {
+        NewReplyStatusView(draft: draft, mastodonController: mastodonController)
+            .listRowInsets(EdgeInsets(top: 8, leading: 8, bottom: 4, trailing: 8))
+            .listRowSeparator(.hidden)
+        
+        NewHeaderView(draft: draft, instanceFeatures: mastodonController.instanceFeatures)
+            .listRowInsets(EdgeInsets(top: 8, leading: 8, bottom: 4, trailing: 8))
+            .listRowSeparator(.hidden)
+        
+        ContentWarningTextField(draft: draft, focusedField: $focusedField)
+            .listRowInsets(EdgeInsets(top: 8, leading: 8, bottom: 4, trailing: 8))
+            .listRowSeparator(.hidden)
+        
+        NewMainTextView(value: $draft.text, focusedField: $focusedField, handleAttachmentDrop: self.addAttachments)
+            .listRowInsets(EdgeInsets(top: 8, leading: 8, bottom: 4, trailing: 8))
+            .listRowSeparator(.hidden)
+
+        AttachmentsListSection(draft: draft, instanceFeatures: mastodonController.instanceFeatures)
+    }
+    
+    private func addAttachments(_ itemProviders: [NSItemProvider]) {
+        AttachmentsListSection.insertAttachments(in: draft, at: draft.attachments.count, itemProviders: itemProviders)
+    }
+}
+
+private struct NavigationTitleModifier: ViewModifier {
+    let draft: Draft
+    let mastodonController: any ComposeMastodonContext
+    
+    private var navigationTitle: String {
+        if let id = draft.inReplyToID,
+           let status = mastodonController.fetchStatus(id: id) {
+            return "Reply to @\(status.account.acct)"
+        } else if draft.editedStatusID != nil {
+            return "Edit Post"
+        } else {
+            return "New Post"
+        }
+    }
+
+    func body(content: Content) -> some View {
+        content
+            .navigationTitle(navigationTitle)
+            .preference(key: NavigationTitlePreferenceKey.self, value: navigationTitle)
+    }
+}
+
+// Public preference so that the host can read the title.
+public struct NavigationTitlePreferenceKey: PreferenceKey {
+    public static var defaultValue: String? { nil }
+    public static func reduce(value: inout String?, nextValue: () -> String?) {
+        value = value ?? nextValue()
+    }
+}
+
+private struct ToolbarActions: ToolbarContent {
+    @ObservedObject var draft: Draft
+    // Prior to iOS 16, the toolbar content doesn't seem to have access
+    // to the environment form the containing view.
+    let controller: ComposeController
+    
+    var body: some ToolbarContent {
+        ToolbarItem(placement: .cancellationAction) { ToolbarCancelButton(draft: draft) }
+        
+        #if targetEnvironment(macCatalyst)
+        ToolbarItem(placement: .topBarTrailing) { draftsButton }
+        ToolbarItem(placement: .confirmationAction) { postButton }
+        #else
+        ToolbarItem(placement: .confirmationAction) { postOrDraftsButton }
+        #endif
+    }
+    
+    private var draftsButton: some View {
+        Button(action: controller.showDrafts) {
+            Text("Drafts")
+        }
+    }
+    
+    private var postButton: some View {
+        // TODO: don't use the controller for this
+        Button(action: controller.postStatus) {
+            Text(draft.editedStatusID == nil ? "Post" : "Edit")
+        }
+        .keyboardShortcut(.return, modifiers: .command)
+        .disabled(!controller.postButtonEnabled)
+    }
+    
+    #if !targetEnvironment(macCatalyst)
+    @ViewBuilder
+    private var postOrDraftsButton: some View {
+        if draft.hasContent || draft.editedStatusID != nil || !controller.config.allowSwitchingDrafts {
+            postButton
+        } else {
+            draftsButton
+        }
+    }
+    #endif
+}
+
+private struct ToolbarCancelButton: View {
+    let draft: Draft
+    @EnvironmentObject private var controller: ComposeController
+    
+    var body: some View {
+        Button(action: controller.cancel) {
+            Text("Cancel")
+                // otherwise all Buttons in the nav bar are made semibold
+                .font(.system(size: 17, weight: .regular))
+        }
+        .disabled(controller.isPosting)
+        .confirmationDialog("Are you sure?", isPresented: $controller.isShowingSaveDraftSheet) {
+            // edit drafts can't be saved
+            if draft.editedStatusID == nil {
+                Button(action: { controller.cancel(deleteDraft: false) }) {
+                    Text("Save Draft")
+                }
+                Button(role: .destructive, action: { controller.cancel(deleteDraft: true) }) {
+                    Text("Delete Draft")
+                }
+            } else {
+                Button(role: .destructive, action: { controller.cancel(deleteDraft: true) }) {
+                    Text("Cancel Edit")
+                }
+            }
+        }
+    }
+}
+
+enum FocusableField: Hashable {
+    case contentWarning
+    case body
+    case attachmentDescription(UUID)
+    
+    var nextField: FocusableField? {
+        switch self {
+        case .contentWarning:
+            return .body
+        default:
+            return nil
+        }
+    }
+}
+
+#if !os(visionOS) && !targetEnvironment(macCatalyst)
+private struct ToolbarSafeAreaInsetModifier: ViewModifier {
+    @StateObject private var keyboardReader = KeyboardReader()
+    
+    func body(content: Content) -> some View {
+        if #available(iOS 17.0, *) {
+            content
+                .safeAreaPadding(.bottom, keyboardReader.isVisible ? 0 : ComposeToolbarView.height)
+        } else {
+            content
+                .safeAreaInset(edge: .bottom) {
+                    if !keyboardReader.isVisible {
+                        Color.clear.frame(height: ComposeToolbarView.height)
+                    }
+                }
+        }
+    }
+}
+#endif
+
+//#Preview {
+//    ComposeView()
+//}

Packages/ComposeUI/Sources/ComposeUI/Views/ContentWarningTextField.swift

@@ -0,0 +1,38 @@
+//
+//  ContentWarningTextField.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/10/24.
+//
+
+import SwiftUI
+
+struct ContentWarningTextField: View {
+    @ObservedObject var draft: Draft
+    @FocusState.Binding var focusedField: FocusableField?
+    
+    var body: some View {
+        if draft.contentWarningEnabled {
+            EmojiTextField(
+                text: $draft.contentWarning,
+                placeholder: "Write your warning here",
+                maxLength: nil,
+                // TODO: completely replace this with FocusState
+                becomeFirstResponder: .constant(false),
+                focusNextView: Binding(get: {
+                    false
+                }, set: {
+                    if $0 {
+                        focusedField = .body
+                    }
+                })
+            )
+            .focused($focusedField, equals: .contentWarning)
+            .modifier(FocusedInputModifier())
+        }
+    }
+}
+
+//#Preview {
+//    ContentWarningTextField()
+//}

Packages/ComposeUI/Sources/ComposeUI/Views/EmojiTextField.swift

@@ -12,6 +12,7 @@ struct EmojiTextField: UIViewRepresentable {
     
     @EnvironmentObject private var controller: ComposeController
     @Environment(\.colorScheme) private var colorScheme
+    @Environment(\.composeInputBox) private var inputBox
     
     @Binding var text: String
     let placeholder: String
@@ -75,7 +76,11 @@ struct EmojiTextField: UIViewRepresentable {
     }
     
     func makeCoordinator() -> Coordinator {
-        Coordinator(controller: controller, text: $text, focusNextView: focusNextView)
+        let coordinator = Coordinator(controller: controller, text: $text, focusNextView: focusNextView)
+        DispatchQueue.main.async {
+            inputBox.wrappedValue = coordinator
+        }
+        return coordinator
     }
     
     class Coordinator: NSObject, UITextFieldDelegate, ComposeInput {
@@ -113,12 +118,16 @@ struct EmojiTextField: UIViewRepresentable {
         }
         
         func textFieldDidBeginEditing(_ textField: UITextField) {
-            controller.currentInput = self
+            DispatchQueue.main.async {
+                self.controller.currentInput = self
+            }
             autocompleteState = textField.updateAutocompleteState(permittedModes: .emojis)
         }
         
         func textFieldDidEndEditing(_ textField: UITextField) {
-            controller.currentInput = nil
+            DispatchQueue.main.async {
+                self.controller.currentInput = nil
+            }
             autocompleteState = textField.updateAutocompleteState(permittedModes: .emojis)
         }
         

Packages/ComposeUI/Sources/ComposeUI/Views/HeaderView.swift

@@ -29,3 +29,19 @@ struct HeaderView: View {
         }.frame(height: 50)
     }
 }
+
+struct NewHeaderView: View {
+    @ObservedObject var draft: Draft
+    @ObservedObject var instanceFeatures: InstanceFeatures
+    @Environment(\.currentAccount) private var currentAccount
+    
+    private var charactersRemaining: Int {
+        let limit = instanceFeatures.maxStatusChars
+        let cwCount = draft.contentWarningEnabled ? draft.contentWarning.count : 0
+        return limit - (cwCount + CharacterCounter.count(text: draft.text, for: instanceFeatures))
+    }
+    
+    var body: some View {
+        HeaderView(currentAccount: currentAccount, charsRemaining: charactersRemaining)
+    }
+}

Packages/ComposeUI/Sources/ComposeUI/Views/NewMainTextView.swift

@@ -0,0 +1,281 @@
+//
+//  NewMainTextView.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/11/24.
+//
+
+import SwiftUI
+
+struct NewMainTextView: View {
+    static var minHeight: CGFloat { 150 }
+    
+    @Binding var value: String
+    @FocusState.Binding var focusedField: FocusableField?
+    var handleAttachmentDrop: ([NSItemProvider]) -> Void
+    @State private var becomeFirstResponder = true
+    
+    var body: some View {
+        NewMainTextViewRepresentable(value: $value, becomeFirstResponder: $becomeFirstResponder, handleAttachmentDrop: handleAttachmentDrop)
+            .focused($focusedField, equals: .body)
+            .modifier(FocusedInputModifier())
+            .overlay(alignment: .topLeading) {
+                if value.isEmpty {
+                    PlaceholderView()
+                }
+            }
+    }
+}
+
+private struct NewMainTextViewRepresentable: UIViewRepresentable {
+    @Binding var value: String
+    @Binding var becomeFirstResponder: Bool
+    var handleAttachmentDrop: ([NSItemProvider]) -> Void
+    @Environment(\.composeInputBox) private var inputBox
+    @Environment(\.isEnabled) private var isEnabled
+    @Environment(\.colorScheme) private var colorScheme
+    @Environment(\.composeUIConfig.fillColor) private var fillColor
+    @Environment(\.composeUIConfig.useTwitterKeyboard) private var useTwitterKeyboard
+    // TODO: test textSelectionStartsAtBeginning
+    @Environment(\.composeUIConfig.textSelectionStartsAtBeginning) private var textSelectionStartsAtBeginning
+    
+    func makeUIView(context: Context) -> UITextView {
+        // TODO: if we're not doing the pill background, reevaluate whether this version fork is necessary
+        let view = WrappedTextView(usingTextLayoutManager: true)
+        view.addInteraction(UIDropInteraction(delegate: context.coordinator))
+        view.delegate = context.coordinator
+        view.adjustsFontForContentSizeCategory = true
+        view.textContainer.lineBreakMode = .byWordWrapping
+        view.isScrollEnabled = false
+        view.typingAttributes = [
+            .foregroundColor: UIColor.label,
+            .font: UIFontMetrics.default.scaledFont(for: .systemFont(ofSize: 20)),
+        ]
+        
+        view.layer.cornerRadius = 5
+        view.layer.cornerCurve = .continuous
+//        view.layer.shadowColor = UIColor.black.cgColor
+//        view.layer.shadowOpacity = 0.15
+//        view.layer.shadowOffset = .zero
+//        view.layer.shadowRadius = 1
+        
+        if textSelectionStartsAtBeginning {
+            // Update the text immediately so that the selection isn't invalidated by the text changing.
+            context.coordinator.updateTextViewTextIfNecessary(value, textView: view)
+            view.selectedTextRange = view.textRange(from: view.beginningOfDocument, to: view.beginningOfDocument)
+        }
+        
+        return view
+    }
+    
+    func updateUIView(_ uiView: UIViewType, context: Context) {
+        context.coordinator.value = $value
+        context.coordinator.handleAttachmentDrop = handleAttachmentDrop
+        context.coordinator.updateTextViewTextIfNecessary(value, textView: uiView)
+        
+        uiView.isEditable = isEnabled
+        uiView.keyboardType = useTwitterKeyboard ? .twitter : .default
+        #if !os(visionOS)
+        uiView.backgroundColor = colorScheme == .dark ? UIColor(fillColor) : .secondarySystemBackground
+        #endif
+        
+        // Trying to set this with the @FocusState binding in onAppear results in the
+        // keyboard not appearing until after the sheet presentation animation completes :/
+        if becomeFirstResponder {
+            uiView.becomeFirstResponder()
+            DispatchQueue.main.async {
+                becomeFirstResponder = false
+            }
+        }
+    }
+    
+    func makeCoordinator() -> WrappedTextViewCoordinator {
+        let coordinator = WrappedTextViewCoordinator(value: $value, handleAttachmentDrop: handleAttachmentDrop)
+//        DispatchQueue.main.async {
+//            inputBox.wrappedValue = coordinator
+//        }
+        return coordinator
+    }
+    
+    @available(iOS 16.0, *)
+    func sizeThatFits(_ proposal: ProposedViewSize, uiView: UIViewType, context: Context) -> CGSize? {
+        let width = proposal.width ?? 10
+        let size = uiView.sizeThatFits(CGSize(width: width, height: 0))
+        return CGSize(width: width, height: max(NewMainTextView.minHeight, size.height))
+    }
+}
+
+// laxer than the CharacterCounter regex, because we want to find mentions that are being typed but aren't yet complete (e.g., "@a@b")
+private let mentionRegex = try! NSRegularExpression(pattern: "(@[a-z0-9_]+)(?:@[a-z0-9\\-\\.]+)?", options: .caseInsensitive)
+
+private final class WrappedTextViewCoordinator: NSObject {
+    private static let attachment: NSTextAttachment = {
+        let font = UIFont.systemFont(ofSize: 20)
+        let size = /*1.4 * */font.capHeight
+        let renderer = UIGraphicsImageRenderer(size: CGSize(width: size, height: size))
+        let image = renderer.image { ctx in
+            UIColor.systemRed.setFill()
+            ctx.fill(CGRect(x: 0, y: 0, width: size, height: size))
+        }
+        let attachment = NSTextAttachment(image: image)
+        attachment.bounds = CGRect(x: 0, y: -1, width: size + 2, height: size)
+        attachment.lineLayoutPadding = 1
+        return attachment
+    }()
+    
+    var value: Binding<String>
+    var handleAttachmentDrop: ([NSItemProvider]) -> Void
+    
+    init(value: Binding<String>, handleAttachmentDrop: @escaping ([NSItemProvider]) -> Void) {
+        self.value = value
+        self.handleAttachmentDrop = handleAttachmentDrop
+    }
+    
+    private func plainTextFromAttributed(_ attributedText: NSAttributedString) -> String {
+        attributedText.string.replacingOccurrences(of: "\u{FFFC}", with: "")
+    }
+    
+    private func attributedTextFromPlain(_ text: String) -> NSAttributedString {
+        let str = NSMutableAttributedString(string: text)
+        let mentionMatches = CharacterCounter.mention.matches(in: text, range: NSRange(location: 0, length: str.length))
+        for match in mentionMatches.reversed() {
+            str.insert(NSAttributedString(attachment: Self.attachment), at: match.range.location)
+            let range = NSRange(location: match.range.location, length: match.range.length + 1)
+            str.addAttributes([
+                .mention: true,
+                .foregroundColor: UIColor.tintColor,
+            ], range: range)
+        }
+        return str
+    }
+    
+    func updateTextViewTextIfNecessary(_ text: String, textView: UITextView) {
+        if text != plainTextFromAttributed(textView.attributedText) {
+            textView.attributedText = attributedTextFromPlain(text)
+        }
+    }
+    
+    private func updateAttributes(in textView: UITextView) {
+        let str = NSMutableAttributedString(attributedString: textView.attributedText!)
+        var changed = false
+        var cursorOffset = 0
+        
+        // remove existing mentions that aren't valid
+        str.enumerateAttribute(.mention, in: NSRange(location: 0, length: str.length), options: .reverse) { value, range, stop in
+            var substr = (str.string as NSString).substring(with: range)
+            let hasTextAttachment = substr.unicodeScalars.first == UnicodeScalar(NSTextAttachment.character)
+            if hasTextAttachment {
+                substr = String(substr.dropFirst())
+            }
+            if mentionRegex.numberOfMatches(in: substr, range: NSRange(location: 0, length: substr.utf16.count)) == 0 {
+                changed = true
+                str.removeAttribute(.mention, range: range)
+                str.removeAttribute(.foregroundColor, range: range)
+                if hasTextAttachment {
+                    str.deleteCharacters(in: NSRange(location: range.location, length: 1))
+                    cursorOffset -= 1
+                }
+            }
+        }
+        
+        // add mentions for those missing
+        let mentionMatches = mentionRegex.matches(in: str.string, range: NSRange(location: 0, length: str.length))
+        for match in mentionMatches.reversed() {
+            var attributeRange = NSRange()
+            let attribute = str.attribute(.mention, at: match.range.location, effectiveRange: &attributeRange)
+            // the attribute range should always be one greater than the match range, to account for the text attachment
+            if attribute == nil || attributeRange.length <= match.range.length {
+                changed = true
+                let newAttributeRange: NSRange
+                if attribute == nil {
+                    str.insert(NSAttributedString(attachment: Self.attachment), at: match.range.location)
+                    newAttributeRange = NSRange(location: match.range.location, length: match.range.length + 1)
+                    cursorOffset += 1
+                } else {
+                    newAttributeRange = match.range
+                }
+                str.addAttributes([
+                    .mention: true,
+                    .foregroundColor: UIColor.tintColor,
+                ], range: newAttributeRange)
+            }
+        }
+        
+        if changed {
+            let selection = textView.selectedRange
+            
+            textView.attributedText = str
+            
+            textView.selectedRange = NSRange(location: selection.location + cursorOffset, length: selection.length)
+        }
+    }
+}
+
+extension WrappedTextViewCoordinator: UITextViewDelegate {
+    func textViewDidChange(_ textView: UITextView) {
+        if textView.text.isEmpty {
+            textView.typingAttributes = [
+                .foregroundColor: UIColor.label,
+                .font: UIFontMetrics.default.scaledFont(for: .systemFont(ofSize: 20)),
+            ]
+        } else {
+            updateAttributes(in: textView)
+        }
+        
+        let plain = plainTextFromAttributed(textView.attributedText)
+        if plain != value.wrappedValue {
+            value.wrappedValue = plain
+        }
+    }
+    
+    func textViewDidChangeSelection(_ textView: UITextView) {
+    }
+}
+
+//extension WrappedTextViewCoordinator: ComposeInput {
+//    
+//}
+
+// Because of FB11790805, we can't handle drops for the entire screen.
+// The onDrop modifier also doesn't work when applied to the NewMainTextView.
+// So, manually add the UIInteraction to at least handle that.
+extension WrappedTextViewCoordinator: UIDropInteractionDelegate {
+    func dropInteraction(_ interaction: UIDropInteraction, canHandle session: any UIDropSession) -> Bool {
+        session.canLoadObjects(ofClass: DraftAttachment.self)
+    }
+    func dropInteraction(_ interaction: UIDropInteraction, sessionDidUpdate session: any UIDropSession) -> UIDropProposal {
+        UIDropProposal(operation: .copy)
+    }
+    func dropInteraction(_ interaction: UIDropInteraction, performDrop session: any UIDropSession) {
+        handleAttachmentDrop(session.items.map(\.itemProvider))
+    }
+}
+
+private final class WrappedTextView: UITextView {
+}
+
+private extension NSAttributedString.Key {
+    static let mention = NSAttributedString.Key("Tusker.ComposeUI.mention")
+}
+
+private struct PlaceholderView: View {
+    @State private var placeholder: PlaceholderController.PlaceholderView = PlaceholderController.makePlaceholderView()
+    @ScaledMetric private var fontSize = 20
+    
+    private var placeholderOffset: CGSize {
+        #if os(visionOS)
+        CGSize(width: 8, height: 8)
+        #else
+        CGSize(width: 4, height: 8)
+        #endif
+    }
+
+    var body: some View {
+        placeholder
+            .font(.system(size: fontSize))
+            .foregroundStyle(.secondary)
+            .offset(placeholderOffset)
+            .accessibilityHidden(true)
+            .allowsHitTesting(false)
+    }
+}

Packages/ComposeUI/Sources/ComposeUI/Views/PostProgressView.swift

@@ -0,0 +1,21 @@
+//
+//  PostProgressView.swift
+//  ComposeUI
+//
+//  Created by Shadowfacts on 8/10/24.
+//
+
+import SwiftUI
+
+struct PostProgressView: View {
+    @ObservedObject var poster: PostService
+    
+    var body: some View {
+        // can't use SwiftUI.ProgressView because there's no UIProgressView.Style.bar equivalent, see FB8587149
+        WrappedProgressView(value: poster.currentStep, total: poster.totalSteps)
+    }
+}
+
+//#Preview {
+//    PostProgressView()
+//}

Packages/ComposeUI/Sources/ComposeUI/Views/ReplyStatusView.swift

@@ -132,3 +132,21 @@ private struct AvatarContainerRepresentable<Content: View>: UIViewControllerRepr
         }
     }
 }
+
+struct NewReplyStatusView: View {
+    let draft: Draft
+    let mastodonController: any ComposeMastodonContext
+    
+    var body: some View {
+        if let id = draft.inReplyToID,
+           let status = mastodonController.fetchStatus(id: id) {
+            ReplyStatusView(
+                status: status,
+                rowTopInset: 8,
+                globalFrameOutsideList: .zero
+            )
+            // i don't know why swiftui can't infer this from the status that's passed into the ReplyStatusView changing
+            .id(id)
+        }
+    }
+}

Packages/Duckable/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "Duckable",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.

Packages/GalleryVC/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "GalleryVC",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, making them visible to other packages.
@@ -14,15 +14,11 @@ let package = Package(
             name: "GalleryVC",
             targets: ["GalleryVC"]),
     ],
-    dependencies: [
-        .package(path: "../TuskerComponents"),
-    ],
     targets: [
         // Targets are the basic building blocks of a package, defining a module or a test suite.
         // Targets can depend on other targets in this package and products from dependencies.
         .target(
             name: "GalleryVC",
-            dependencies: ["TuskerComponents"],
             swiftSettings: [
                 .swiftLanguageMode(.v5)
             ]),

Packages/GalleryVC/Sources/GalleryVC/GalleryContentViewController.swift

@@ -15,7 +15,7 @@ public protocol GalleryContentViewController: UIViewController {
     var caption: String? { get }
     var contentOverlayAccessoryViewController: UIViewController? { get }
     var bottomControlsAccessoryViewController: UIViewController? { get }
-    var presentationAnimation: GalleryContentPresentationAnimation { get }
+    var canAnimateFromSourceView: Bool { get }
     
     func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool)
     func galleryContentDidAppear()
@@ -31,8 +31,8 @@ public extension GalleryContentViewController {
         nil
     }
     
-    var presentationAnimation: GalleryContentPresentationAnimation {
-        .fromSourceView
+    var canAnimateFromSourceView: Bool {
+        true
     }
     
     func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool) {
@@ -44,9 +44,3 @@ public extension GalleryContentViewController {
     func galleryContentWillDisappear() {
     }
 }
-
-public enum GalleryContentPresentationAnimation {
-    case fade
-    case fromSourceView
-    case fromSourceViewWithoutSnapshot
-}

Packages/GalleryVC/Sources/GalleryVC/GalleryDismissAnimationController.swift

@@ -30,37 +30,12 @@ class GalleryDismissAnimationController: NSObject, UIViewControllerAnimatedTrans
         
         let itemViewController = from.currentItemViewController
         
-        if itemViewController.content.presentationAnimation == .fade || (UIAccessibility.prefersCrossFadeTransitions && interactiveVelocity == nil) {
+        if !itemViewController.content.canAnimateFromSourceView || (UIAccessibility.prefersCrossFadeTransitions && interactiveVelocity == nil) {
             animateCrossFadeTransition(using: transitionContext)
             return
         }
         
         let container = transitionContext.containerView
-
-        // Moving `to.view` to the container is necessary when the presenting VC (i.e., `to`)
-        // is in the window's root presentation.
-        // But it breaks when the gallery is presented from a sheet-presented VC--in which case
-        // `to.view` is already in the view hierarchy at this point; and adding it to the
-        // container causees it to be removed when the transition completes.
-        if to.view.superview == nil {
-            to.view.frame = container.bounds
-            container.addSubview(to.view)
-        }
-        
-        let sourceSnapshot: UIView? = if itemViewController.content.presentationAnimation == .fromSourceViewWithoutSnapshot {
-            nil
-        } else {
-            sourceView.snapshotView(afterScreenUpdates: false)
-        }
-        if let sourceSnapshot {
-            let snapshotContainer = sourceView.ancestorForInsertingSnapshot
-            snapshotContainer.addSubview(sourceSnapshot)
-            let sourceFrameInShapshotContainer = snapshotContainer.convert(sourceView.bounds, from: sourceView)
-            sourceSnapshot.frame = sourceFrameInShapshotContainer
-            sourceSnapshot.layer.opacity = 1
-            self.sourceView.layer.opacity = 0
-        }
-
         let sourceFrameInContainer = container.convert(sourceView.bounds, from: sourceView)
         let destFrameInContainer = container.convert(itemViewController.content.view.bounds, from: itemViewController.content.view)
         
@@ -73,39 +48,38 @@ class GalleryDismissAnimationController: NSObject, UIViewControllerAnimatedTrans
                 .translatedBy(x: destFrameInContainer.midX - sourceFrameInContainer.midX, y: destFrameInContainer.midY - sourceFrameInContainer.midY)
                 .scaledBy(x: scale, y: scale)
             sourceView.transform = sourceToDestTransform
-            sourceSnapshot?.transform = sourceToDestTransform
         } else {
             appliedSourceToDestTransform = false
         }
         
+        // Moving `to.view` to the container is necessary when the presenting VC (i.e., `to`)
+        // is in the window's root presentation.
+        // But it breaks when the gallery is presented from a sheet-presented VC--in which case
+        // `to.view` is already in the view hierarchy at this point; and adding it to the
+        // container causees it to be removed when the transition completes.
+        if to.view.superview == nil {
+            to.view.frame = container.bounds
+            container.addSubview(to.view)
+        }
+        
         from.view.frame = container.bounds
         container.addSubview(from.view)
-        
-        let contentContainer = UIView()
-        contentContainer.layer.masksToBounds = true
-        contentContainer.frame = destFrameInContainer
-        container.addSubview(contentContainer)
-        
+
         let content = itemViewController.takeContent()
         content.view.translatesAutoresizingMaskIntoConstraints = true
-        content.view.transform = .identity
-        content.view.layer.opacity = 1
-        content.view.frame = contentContainer.bounds
-        contentContainer.addSubview(content.view)
-
-        container.layoutIfNeeded()
+        content.view.layer.masksToBounds = true
+        container.addSubview(content.view)
         
-        // Hide overlaid controls immediately, to prevent the Live Text button's position
-        // getting caught up in the rest of the animation.
-        UIView.animate(withDuration: 0.1) {
-            content.setControlsVisible(false, animated: false, dueToUserInteraction: false)
-        }
+        content.view.frame = destFrameInContainer
+        content.view.layer.opacity = 1
+        
+        container.layoutIfNeeded()
         
         let duration = self.transitionDuration(using: transitionContext)
         var initialVelocity: CGVector
         if let interactiveVelocity,
            let interactiveTranslation,
-           // very short/fast flicks don't transfer their velocity, since it makes size change animation look wacky due to the spring's initial undershoot
+           // very short/fast flicks don't transfer their velocity, since it makes size change animation look wacky due to the springs initial undershoot
            sqrt(pow(interactiveTranslation.x, 2) + pow(interactiveTranslation.y, 2)) > 100,
            sqrt(pow(interactiveVelocity.x, 2) + pow(interactiveVelocity.y, 2)) < 2000 {
             let xDistance = sourceFrameInContainer.midX - destFrameInContainer.midX
@@ -128,34 +102,14 @@ class GalleryDismissAnimationController: NSObject, UIViewControllerAnimatedTrans
             
             if appliedSourceToDestTransform {
                 self.sourceView.transform = origSourceTransform
-                sourceSnapshot?.transform = origSourceTransform
             }
-            
-            contentContainer.frame = sourceFrameInContainer
-            // Using sourceSizeWithDestAspectRatioCenteredInContentContainer does not seem to be necessary here.
-            // I guess autoresizing takes care of it?
+            content.view.frame = sourceFrameInContainer
+            content.view.layer.opacity = 0
             
             itemViewController.setControlsVisible(false, animated: false, dueToUserInteraction: false)
         }
         
-        // Delay fading out the content because if it's still big while it's semi-transparent,
-        // seeing the stuff behind it looks odd.
-        animator.addAnimations({
-            content.view.layer.opacity = 0
-        }, delayFactor: 0.35)
-        
-        if let sourceSnapshot {
-            animator.addAnimations({
-                self.sourceView.layer.opacity = 1
-                sourceSnapshot.layer.opacity = 0
-            }, delayFactor: 0.5)
-        }
-        
         animator.addCompletion { _ in
-            sourceSnapshot?.removeFromSuperview()
-            
-            // Having dismissed, we don't need to undo any of the changes to the content VC.
-            
             transitionContext.completeTransition(true)
         }
         

Packages/GalleryVC/Sources/GalleryVC/GalleryDismissInteraction.swift

@@ -20,8 +20,6 @@ class GalleryDismissInteraction: NSObject {
     private(set) var dismissVelocity: CGPoint?
     private(set) var dismissTranslation: CGPoint?
     
-    private var cancelAnimator: UIViewPropertyAnimator?
-    
     init(viewController: GalleryViewController) {
         self.viewController = viewController
         super.init()
@@ -40,8 +38,6 @@ class GalleryDismissInteraction: NSObject {
             content = viewController.currentItemViewController.takeContent()
             content!.view.translatesAutoresizingMaskIntoConstraints = true
             content!.view.frame = origContentFrameInGallery!
-            // Make sure the context remains behind the controls
-            content!.view.layer.zPosition = -1000
             viewController.view.addSubview(content!.view)
             
             origControlsVisible = viewController.currentItemViewController.controlsVisible
@@ -57,42 +53,12 @@ class GalleryDismissInteraction: NSObject {
             let translation = recognizer.translation(in: viewController.view)
             let velocity = recognizer.velocity(in: viewController.view)
             
-            let translationMagnitude = sqrt(translation.x.magnitudeSquared + translation.y.magnitudeSquared)
-            let velocityMagnitude = sqrt(velocity.x.magnitudeSquared + velocity.y.magnitudeSquared)
-            
-            if translationMagnitude < 150 && velocityMagnitude < 500 {
-                isActive = false
-                
-                cancelAnimator?.stopAnimation(true)
-                
-                let spring = UISpringTimingParameters(mass: 1, stiffness: 439, damping: 42, initialVelocity: .zero)
-                cancelAnimator = UIViewPropertyAnimator(duration: 0.2, timingParameters: spring)
-                cancelAnimator!.addAnimations {
-                    self.content!.view.frame = self.origContentFrameInGallery!
-                    self.viewController.currentItemViewController.setControlsVisible(self.origControlsVisible!, animated: false, dueToUserInteraction: false)
-                }
-                cancelAnimator!.addCompletion { _ in
-                    guard !self.isActive else {
-                        // bail in case the animation finishing raced with the user's interaction
-                        return
-                    }
-                    self.content!.view.layer.zPosition = 0
-                    self.content!.view.removeFromSuperview()
-                    self.viewController.currentItemViewController.addContent()
-                    self.content = nil
-                    self.origContentFrameInGallery = nil
-                    self.origControlsVisible = nil
-                }
-                cancelAnimator!.startAnimation()
+            dismissVelocity = velocity
+            dismissTranslation = translation
+            viewController.dismiss(animated: true)
 
-            } else {
-                dismissVelocity = velocity
-                dismissTranslation = translation
-                viewController.dismiss(animated: true)
-                
-                // don't unset this until after dismiss is called, so that the dismiss animation controller can read it
-                isActive = false
-            }
+            // don't unset this until after dismiss is called, so that the dismiss animation controller can read it
+            isActive = false
             
         default:
             break

Packages/GalleryVC/Sources/GalleryVC/GalleryItemViewController.swift

@@ -11,7 +11,6 @@ import AVFoundation
 @MainActor
 protocol GalleryItemViewControllerDelegate: AnyObject {
     func isGalleryBeingPresented() -> Bool
-    func isGalleryBeingDismissed() -> Bool
     func addPresentationAnimationCompletion(_ block: @escaping () -> Void)
     func galleryItemClose(_ item: GalleryItemViewController)
     func galleryItemApplicationActivities(_ item: GalleryItemViewController) -> [UIActivity]?
@@ -70,10 +69,6 @@ class GalleryItemViewController: UIViewController {
         scrollView = UIScrollView()
         scrollView.translatesAutoresizingMaskIntoConstraints = false
         scrollView.delegate = self
-        // We calculate zoom/position ignoring the safe area, so content insets need to not incorporate it either.
-        // Otherwise, content that fills the screen (extending into the safe area) may still end up scrollable
-        // (this is readily observable with tall images on a landscape iPad).
-        scrollView.contentInsetAdjustmentBehavior = .never
         
         view.addSubview(scrollView)
         
@@ -377,27 +372,13 @@ class GalleryItemViewController: UIViewController {
     }
     
     private func updateTopControlsInsets() {
-        guard delegate?.isGalleryBeingDismissed() != true else {
-            return
-        }
         let notchedDeviceTopInsets: [CGFloat] = [
             44, // iPhone X, Xs, Xs Max, 11 Pro, 11 Pro Max
             48, // iPhone XR, 11
             47, // iPhone 12, 12 Pro, 12 Pro Max, 13, 13 Pro, 13 Pro Max, 14, 14 Plus
             50, // iPhone 12 mini, 13 mini
         ]
-        let topInset: CGFloat
-        switch view.window?.windowScene?.interfaceOrientation {
-        case .portraitUpsideDown:
-            topInset = view.safeAreaInsets.bottom
-        case .landscapeLeft:
-            topInset = view.safeAreaInsets.right
-        case .landscapeRight:
-            topInset = view.safeAreaInsets.left
-        default:
-            topInset = view.safeAreaInsets.top
-        }
-        if notchedDeviceTopInsets.contains(topInset) {
+        if notchedDeviceTopInsets.contains(view.safeAreaInsets.top) {
             // the notch width is not the same for the iPhones 13,
             // but what we actually want is the same offset from the edges
             // since the corner radius didn't change
@@ -406,7 +387,7 @@ class GalleryItemViewController: UIViewController {
             let offset = (earWidth - (shareButton.imageView?.bounds.width ?? 0)) / 2
             shareButtonLeadingConstraint.constant = offset
             closeButtonTrailingConstraint.constant = offset
-        } else if topInset == 0 {
+        } else if view.safeAreaInsets.top == 0 {
             // square corner devices
             shareButtonLeadingConstraint.constant = 8
             shareButtonTopConstraint.constant = 8

Packages/GalleryVC/Sources/GalleryVC/GalleryPresentationAnimationController.swift

@@ -25,31 +25,11 @@ class GalleryPresentationAnimationController: NSObject, UIViewControllerAnimated
         
         let itemViewController = to.currentItemViewController
 
-        if itemViewController.content.presentationAnimation == .fade || UIAccessibility.prefersCrossFadeTransitions {
+        if !itemViewController.content.canAnimateFromSourceView || UIAccessibility.prefersCrossFadeTransitions {
             animateCrossFadeTransition(using: transitionContext)
             return
         }
         
-        // Try to effectively "fade out" anything that's on top of the source view.
-        // The 0.1 duration makes this happen faster than the rest of the animation,
-        // and so less noticeable.
-        let sourceSnapshot: UIView? = if itemViewController.content.presentationAnimation == .fromSourceViewWithoutSnapshot {
-            nil
-        } else {
-            sourceView.snapshotView(afterScreenUpdates: false)
-        }
-        if let sourceSnapshot {
-            let snapshotContainer = sourceView.ancestorForInsertingSnapshot
-            snapshotContainer.addSubview(sourceSnapshot)
-            let sourceFrameInShapshotContainer = snapshotContainer.convert(sourceView.bounds, from: sourceView)
-            sourceSnapshot.frame = sourceFrameInShapshotContainer
-            sourceSnapshot.transform = sourceView.transform
-            sourceSnapshot.layer.opacity = 0
-            UIView.animate(withDuration: 0.1) {
-                sourceSnapshot.layer.opacity = 1
-            }
-        }
-        
         let container = transitionContext.containerView
         to.view.frame = container.bounds
         container.addSubview(to.view)
@@ -76,70 +56,21 @@ class GalleryPresentationAnimationController: NSObject, UIViewControllerAnimated
             sourceToDestTransform = nil
         }
         
-        // Grab these before taking the content out and changing the transform.
-        let origContentTransform = itemViewController.content.view.transform
-        let origContentFrame = itemViewController.content.view.frame
-        
-        // The content container provides the clipping for the content view,
-        // which, in case the source/dest aspect ratios don't match, makes
-        // it look like the content is expanding out from the source rect.
-        let contentContainer = UIView()
-        contentContainer.layer.masksToBounds = true
-        container.insertSubview(contentContainer, belowSubview: to.view)
         let content = itemViewController.takeContent()
         content.view.translatesAutoresizingMaskIntoConstraints = true
-        content.view.transform = .identity
-        // The fade-in makes the aspect ratio handling look a little bit worse,
-        // but papers over the z-index change and potential corner radius change.
-        content.view.layer.opacity = 0
-        contentContainer.addSubview(content.view)
+        container.insertSubview(content.view, belowSubview: to.view)
 
         // Use a separate dimming view from to.view, so that the gallery controls can be in front of the moving content.
         let dimmingView = UIView()
         dimmingView.backgroundColor = .black
         dimmingView.frame = container.bounds
         dimmingView.layer.opacity = 0
-        container.insertSubview(dimmingView, belowSubview: contentContainer)
+        container.insertSubview(dimmingView, belowSubview: content.view)
 
         to.view.backgroundColor = nil
         to.view.layer.opacity = 0
-        
-        contentContainer.frame = sourceFrameInContainer
-        
-        let sourceAspectRatio: CGFloat = if sourceFrameInContainer.height > 0 {
-            sourceFrameInContainer.width / sourceFrameInContainer.height
-        } else {
-            0
-        }
-        let destAspectRatio: CGFloat = if destFrameInContainer.height > 0 {
-            destFrameInContainer.width / destFrameInContainer.height
-        } else {
-            0
-        }
-        let sourceSizeWithDestAspectRatioCenteredInContentContainer: CGRect
-        if 0.001 < abs(sourceAspectRatio - destAspectRatio) {
-            // asepct ratios are effectively equal
-            sourceSizeWithDestAspectRatioCenteredInContentContainer = CGRect(origin: .zero, size: sourceFrameInContainer.size)
-        } else if sourceAspectRatio < destAspectRatio {
-            // source aspect ratio is narrow/taller than dest
-            let width = sourceFrameInContainer.height * destAspectRatio
-            sourceSizeWithDestAspectRatioCenteredInContentContainer = CGRect(
-                x: -(width - sourceFrameInContainer.width) / 2,
-                y: 0,
-                width: width,
-                height: sourceFrameInContainer.height
-            )
-        } else {
-            // source aspect ratio is wider/shorter than dest
-            let height = sourceFrameInContainer.width / destAspectRatio
-            sourceSizeWithDestAspectRatioCenteredInContentContainer = CGRect(
-                x: 0,
-                y: -(height - sourceFrameInContainer.height) / 2,
-                width: sourceFrameInContainer.width,
-                height: height
-            )
-        }
-        content.view.frame = sourceSizeWithDestAspectRatioCenteredInContentContainer
+        content.view.frame = sourceFrameInContainer
+        content.view.layer.opacity = 0
         
         container.layoutIfNeeded()
         
@@ -147,14 +78,8 @@ class GalleryPresentationAnimationController: NSObject, UIViewControllerAnimated
         itemViewController.setControlsVisible(false, animated: false, dueToUserInteraction: false)
 
         let duration = self.transitionDuration(using: transitionContext)
-        // less bounce on bigger screens
-        let spring = if UIDevice.current.userInterfaceIdiom == .pad {
-            // roughly equivalent to duration: 0.35, bounce: 0.2
-            UISpringTimingParameters(mass: 1, stiffness: 322, damping: 28, initialVelocity: .zero)
-        } else {
-            // roughly equivalent to duration: 0.35, bounce: 0.3
-            UISpringTimingParameters(mass: 1, stiffness: 322, damping: 25, initialVelocity: .zero)
-        }
+        // rougly equivalent to duration: 0.35, bounce: 0.3
+        let spring = UISpringTimingParameters(mass: 1, stiffness: 322, damping: 25, initialVelocity: .zero)
         let animator = UIViewPropertyAnimator(duration: duration, timingParameters: spring)
         
         animator.addAnimations {
@@ -162,35 +87,25 @@ class GalleryPresentationAnimationController: NSObject, UIViewControllerAnimated
             
             to.view.layer.opacity = 1
             
-            contentContainer.frame = destFrameInContainer
-            content.view.frame = contentContainer.bounds
+            content.view.frame = destFrameInContainer
             content.view.layer.opacity = 1
-
+            
             itemViewController.setControlsVisible(true, animated: false, dueToUserInteraction: false)
 
             if let sourceToDestTransform {
-                sourceSnapshot?.transform = sourceToDestTransform
                 self.sourceView.transform = sourceToDestTransform
             }
         }
         
         animator.addCompletion { _ in
-            sourceSnapshot?.removeFromSuperview()
-            self.sourceView.layer.opacity = 1
-            if sourceToDestTransform != nil {
-                self.sourceView.transform = origSourceTransform
-            }
-
-            contentContainer.removeFromSuperview()
             dimmingView.removeFromSuperview()
             
             to.view.backgroundColor = .black
             
-            // Reset the properties we changed before re-adding the content to the scroll view.
-            // (I would expect UIScrollView to effectively do this itself, but w/e.)
-            content.view.transform = origContentTransform
-            content.view.frame = origContentFrame
-
+            if sourceToDestTransform != nil {
+                self.sourceView.transform = origSourceTransform
+            }
+            
             itemViewController.addContent()
             
             transitionContext.completeTransition(true)

Packages/GalleryVC/Sources/GalleryVC/GalleryViewController.swift

@@ -139,10 +139,6 @@ extension GalleryViewController: GalleryItemViewControllerDelegate {
         isBeingPresented
     }
     
-    func isGalleryBeingDismissed() -> Bool {
-        isBeingDismissed
-    }
-    
     func addPresentationAnimationCompletion(_ block: @escaping () -> Void) {
         presentationAnimationCompletionHandlers.append(block)
     }

Packages/GalleryVC/Sources/GalleryVC/UIView+Utilities.swift

@@ -1,26 +0,0 @@
-//
-//  UIView+Utilities.swift
-//  GalleryVC
-//
-//  Created by Shadowfacts on 11/24/24.
-//
-
-import UIKit
-
-extension UIView {
-    
-    var ancestorForInsertingSnapshot: UIView {
-        var view = self
-        while let superview = view.superview {
-            if superview.layer.masksToBounds {
-                return superview
-            } else if superview is UIScrollView {
-                return self
-            } else {
-                view = superview
-            }
-        }
-        return view
-    }
-    
-}

Packages/InstanceFeatures/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "InstanceFeatures",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.

Packages/MatchedGeometryPresentation/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "MatchedGeometryPresentation",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, making them visible to other packages.

Packages/Pachyderm/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "Pachyderm",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.

Packages/Pachyderm/Sources/Pachyderm/Client.swift

@@ -25,30 +25,27 @@ public struct Client: Sendable {
     
     public var timeoutInterval: TimeInterval = 60
     
-    private static let dateFormatter: DateFormatter = {
+    static let decoder: JSONDecoder = {
+        let decoder = JSONDecoder()
+        
         let formatter = DateFormatter()
         formatter.dateFormat = "yyyy-MM-dd'T'HH:mm:ss.SZ"
         formatter.timeZone = TimeZone(abbreviation: "UTC")
         formatter.locale = Locale(identifier: "en_US_POSIX")
-        return formatter
-    }()
-    private static let iso8601Formatter = ISO8601DateFormatter()
-    private static func decodeDate(string: String) -> Date? {
-        // for the next time mastodon accidentally changes date formats >.>
-        return dateFormatter.date(from: string) ?? iso8601Formatter.date(from: string)
-    }
-    
-    static let decoder: JSONDecoder = {
-        let decoder = JSONDecoder()
+        let iso8601 = ISO8601DateFormatter()
         decoder.dateDecodingStrategy = .custom({ (decoder) in
             let container = try decoder.singleValueContainer()
             let str = try container.decode(String.self)
-            if let date = Self.decodeDate(string: str) {
+            // for the next time mastodon accidentally changes date formats >.>
+            if let date = formatter.date(from: str) {
+                return date
+            } else if let date = iso8601.date(from: str) {
                 return date
             } else {
                 throw DecodingError.typeMismatch(Date.self, .init(codingPath: container.codingPath, debugDescription: "unexpected date format: \(str)"))
             }
         })
+        
         return decoder
     }()
     
@@ -108,15 +105,6 @@ public struct Client: Sendable {
         return task
     }
     
-    private func error(from response: HTTPURLResponse) -> ErrorType {
-        if response.statusCode == 429,
-           let date = response.value(forHTTPHeaderField: "X-RateLimit-Reset").flatMap(Self.decodeDate) {
-            return .rateLimited(date)
-        } else {
-            return .unexpectedStatus(response.statusCode)
-        }
-    }
-    
     @discardableResult
     public func run<Result: Sendable>(_ request: Request<Result>) async throws -> (Result, Pagination?) {
         return try await withCheckedThrowingContinuation { continuation in
@@ -587,8 +575,6 @@ extension Client {
                 return "Invalid Model"
             case .mastodonError(let code, let error):
                 return "Server Error (\(code)): \(error)"
-            case .rateLimited(let reset):
-                return "Rate Limited Until \(reset.formatted(date: .omitted, time: .standard))"
             }
         }
     }
@@ -599,7 +585,6 @@ extension Client {
         case invalidResponse
         case invalidModel(Swift.Error)
         case mastodonError(Int, String)
-        case rateLimited(Date)
     }
     
     enum NodeInfoError: LocalizedError {

Packages/Pachyderm/Sources/Pachyderm/Model/Emoji.swift

@@ -22,12 +22,7 @@ public struct Emoji: Codable, Sendable {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         
         self.shortcode = try container.decode(String.self, forKey: .shortcode)
-        do {
-            self.url = try container.decode(WebURL.self, forKey: .url)
-        } catch {
-            let s = try? container.decode(String.self, forKey: .url)
-            throw DecodingError.dataCorrupted(.init(codingPath: container.codingPath + [CodingKeys.url], debugDescription: "Could not decode URL '\(s ?? "<failed to decode string>")'", underlyingError: error))
-        }
+        self.url = try container.decode(WebURL.self, forKey: .url)
         self.staticURL = try container.decode(WebURL.self, forKey: .staticURL)
         self.visibleInPicker = try container.decode(Bool.self, forKey: .visibleInPicker)
         self.category = try container.decodeIfPresent(String.self, forKey: .category)

Packages/Pachyderm/Sources/Pachyderm/Model/NodeInfo.swift

@@ -11,15 +11,9 @@ import Foundation
 public struct NodeInfo: Decodable, Sendable, Equatable {
     public let version: String
     public let software: Software
-    public let metadata: Metadata
     
     public struct Software: Decodable, Sendable, Equatable {
         public let name: String
         public let version: String
     }
-    
-    public struct Metadata: Decodable, Sendable, Equatable {
-        public let nodeName: String
-        public let nodeDescription: String
-    }
 }

Packages/Pachyderm/Tests/PachydermTests/NotificationGroupTests.swift

@@ -197,72 +197,72 @@ class NotificationGroupTests: XCTestCase {
 
     func testGroupSimple() {
         let groups = NotificationGroup.createGroups(notifications: [likeA1, likeA2], only: [.favourite])
-        XCTAssertEqual(groups, [NotificationGroup(notifications: [likeA1, likeA2], kind: .favourite)!])
+        XCTAssertEqual(groups, [NotificationGroup(notifications: [likeA1, likeA2])!])
     }
     
     func testGroupWithOtherGroupableInBetween() {
         let groups = NotificationGroup.createGroups(notifications: [likeA1, likeB, likeA2], only: [.favourite])
         XCTAssertEqual(groups, [
-            NotificationGroup(notifications: [likeA1, likeA2], kind: .favourite)!,
-            NotificationGroup(notifications: [likeB], kind: .favourite)!,
+            NotificationGroup(notifications: [likeA1, likeA2])!,
+            NotificationGroup(notifications: [likeB])!,
         ])
     }
     
     func testDontGroupWithUngroupableInBetween() {
         let groups = NotificationGroup.createGroups(notifications: [likeA1, mentionB, likeA2], only: [.favourite])
         XCTAssertEqual(groups, [
-            NotificationGroup(notifications: [likeA1], kind: .favourite)!,
-            NotificationGroup(notifications: [mentionB], kind: .mention)!,
-            NotificationGroup(notifications: [likeA2], kind: .favourite)!,
+            NotificationGroup(notifications: [likeA1])!,
+            NotificationGroup(notifications: [mentionB])!,
+            NotificationGroup(notifications: [likeA2])!,
         ])
     }
 
     func testMergeSimpleGroups() {
-        let group1 = NotificationGroup(notifications: [likeA1], kind: .favourite)!
-        let group2 = NotificationGroup(notifications: [likeA2], kind: .favourite)!
+        let group1 = NotificationGroup(notifications: [likeA1])!
+        let group2 = NotificationGroup(notifications: [likeA2])!
         let merged = NotificationGroup.mergeGroups(first: [group1], second: [group2], only: [.favourite])
         XCTAssertEqual(merged, [
-            NotificationGroup(notifications: [likeA1, likeA2], kind: .favourite)!
+            NotificationGroup(notifications: [likeA1, likeA2])!
         ])
     }
     
     func testMergeGroupsWithOtherGroupableInBetween() {
-        let group1 = NotificationGroup(notifications: [likeA1], kind: .favourite)!
-        let group2 = NotificationGroup(notifications: [likeB], kind: .favourite)!
-        let group3 = NotificationGroup(notifications: [likeA2], kind: .favourite)!
+        let group1 = NotificationGroup(notifications: [likeA1])!
+        let group2 = NotificationGroup(notifications: [likeB])!
+        let group3 = NotificationGroup(notifications: [likeA2])!
         let merged = NotificationGroup.mergeGroups(first: [group1, group2], second: [group3], only: [.favourite])
         XCTAssertEqual(merged, [
-            NotificationGroup(notifications: [likeA1, likeA2], kind: .favourite)!,
-            NotificationGroup(notifications: [likeB], kind: .favourite)!,
+            NotificationGroup(notifications: [likeA1, likeA2])!,
+            NotificationGroup(notifications: [likeB])!,
         ])
         
         let merged2 = NotificationGroup.mergeGroups(first: [group1], second: [group2, group3], only: [.favourite])
         XCTAssertEqual(merged2, [
-            NotificationGroup(notifications: [likeA1, likeA2], kind: .favourite)!,
-            NotificationGroup(notifications: [likeB], kind: .favourite)!,
+            NotificationGroup(notifications: [likeA1, likeA2])!,
+            NotificationGroup(notifications: [likeB])!,
         ])
         
-        let group4 = NotificationGroup(notifications: [likeB2], kind: .favourite)!
-        let group5 = NotificationGroup(notifications: [mentionB], kind: .mention)!
+        let group4 = NotificationGroup(notifications: [likeB2])!
+        let group5 = NotificationGroup(notifications: [mentionB])!
         let merged3 = NotificationGroup.mergeGroups(first: [group1, group5, group2], second: [group4, group3], only: [.favourite])
         print(merged3.count)
         XCTAssertEqual(merged3, [
             group1,
             group5,
-            NotificationGroup(notifications: [likeB, likeB2], kind: .favourite),
+            NotificationGroup(notifications: [likeB, likeB2]),
             group3
         ])
     }
     
     func testDontMergeWithUngroupableInBetween() {
-        let group1 = NotificationGroup(notifications: [likeA1], kind: .favourite)!
-        let group2 = NotificationGroup(notifications: [mentionB], kind: .mention)!
-        let group3 = NotificationGroup(notifications: [likeA2], kind: .favourite)!
+        let group1 = NotificationGroup(notifications: [likeA1])!
+        let group2 = NotificationGroup(notifications: [mentionB])!
+        let group3 = NotificationGroup(notifications: [likeA2])!
         let merged = NotificationGroup.mergeGroups(first: [group1, group2], second: [group3], only: [.favourite])
         XCTAssertEqual(merged, [
-            NotificationGroup(notifications: [likeA1], kind: .favourite)!,
-            NotificationGroup(notifications: [mentionB], kind: .mention)!,
-            NotificationGroup(notifications: [likeA2], kind: .favourite)!,
+            NotificationGroup(notifications: [likeA1])!,
+            NotificationGroup(notifications: [mentionB])!,
+            NotificationGroup(notifications: [likeA2])!,
         ])
     }
 

Packages/PushNotifications/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "PushNotifications",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, making them visible to other packages.

Packages/TTTKit/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "TTTKit",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.

Packages/TuskerComponents/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "TuskerComponents",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.

Packages/TuskerComponents/Sources/TuskerComponents/AsyncPicker.swift

@@ -9,21 +9,14 @@ import SwiftUI
 
 public struct AsyncPicker<V: Hashable, Content: View>: View {
     let titleKey: LocalizedStringKey
-    #if !os(visionOS)
-    @available(iOS, obsoleted: 16.0, message: "Switch to LabeledContent")
-    let labelHidden: Bool
-    #endif
     let alignment: Alignment
     @Binding var value: V
     let onChange: (V) async -> Bool
     let content: Content
     @State private var isLoading = false
     
-    public init(_ titleKey: LocalizedStringKey, labelHidden: Bool = false, alignment: Alignment = .center, value: Binding<V>, onChange: @escaping (V) async -> Bool, @ViewBuilder content: () -> Content) {
+    public init(_ titleKey: LocalizedStringKey, alignment: Alignment = .center, value: Binding<V>, onChange: @escaping (V) async -> Bool, @ViewBuilder content: () -> Content) {
         self.titleKey = titleKey
-        #if !os(visionOS)
-        self.labelHidden = labelHidden
-        #endif
         self.alignment = alignment
         self._value = value
         self.onChange = onChange
@@ -31,25 +24,9 @@ public struct AsyncPicker<V: Hashable, Content: View>: View {
     }
     
     public var body: some View {
-        #if os(visionOS)
         LabeledContent(titleKey) {
             picker
         }
-        #else
-        if #available(iOS 16.0, *) {
-            LabeledContent(titleKey) {
-                picker
-            }
-        } else if labelHidden {
-            picker
-        } else {
-            HStack {
-                Text(titleKey)
-                Spacer()
-                picker
-            }
-        }
-        #endif
     }
     
     private var picker: some View {

Packages/TuskerComponents/Sources/TuskerComponents/AsyncToggle.swift

@@ -10,42 +10,19 @@ import SwiftUI
 
 public struct AsyncToggle: View {
     let titleKey: LocalizedStringKey
-    #if !os(visionOS)
-    @available(iOS, obsoleted: 16.0, message: "Switch to LabeledContent")
-    let labelHidden: Bool
-    #endif
     @Binding var mode: Mode
     let onChange: (Bool) async -> Bool
     
-    public init(_ titleKey: LocalizedStringKey, labelHidden: Bool = false, mode: Binding<Mode>, onChange: @escaping (Bool) async -> Bool) {
+    public init(_ titleKey: LocalizedStringKey, mode: Binding<Mode>, onChange: @escaping (Bool) async -> Bool) {
         self.titleKey = titleKey
-        #if !os(visionOS)
-        self.labelHidden = labelHidden
-        #endif
         self._mode = mode
         self.onChange = onChange
     }
     
     public var body: some View {
-        #if os(visionOS)
         LabeledContent(titleKey) {
             toggleOrSpinner
         }
-        #else
-        if #available(iOS 16.0, *) {
-            LabeledContent(titleKey) {
-                toggleOrSpinner
-            }
-        } else if labelHidden {
-            toggleOrSpinner
-        } else {
-            HStack {
-                Text(titleKey)
-                Spacer()
-                toggleOrSpinner
-            }
-        }
-        #endif
     }
     
     @ViewBuilder

Packages/TuskerComponents/Sources/TuskerComponents/MenuPicker.swift

@@ -47,9 +47,7 @@ public struct MenuPicker<Value: Hashable>: UIViewRepresentable {
     
     private func makeConfiguration() -> UIButton.Configuration {
         var config = UIButton.Configuration.borderless()
-        if #available(iOS 16.0, *) {
-            config.indicator = .popup
-        }
+        config.indicator = .popup
         if buttonStyle.hasIcon {
             config.image = selectedOption.image
         }

Packages/TuskerPreferences/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "TuskerPreferences",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, making them visible to other packages.

Packages/TuskerPreferences/Sources/TuskerPreferences/Supporting Types/FeatureFlag.swift

@@ -9,5 +9,6 @@ import Foundation
 
 public enum FeatureFlag: String, Codable {
     case iPadBrowserNavigation = "ipad-browser-navigation"
+    case composeRewrite = "compose-rewrite"
     case pushNotifCustomEmoji = "push-notif-custom-emoji"
 }

Packages/TuskerPreferences/Sources/TuskerPreferences/SwiftUI/PreferenceObserving.swift

@@ -0,0 +1,37 @@
+//
+//  PreferenceObserving.swift
+//  TuskerPreferences
+//
+//  Created by Shadowfacts on 8/10/24.
+//
+
+import SwiftUI
+import Combine
+
+@propertyWrapper
+public struct PreferenceObserving<Key: PreferenceKey>: DynamicProperty {
+    public typealias PrefKeyPath = KeyPath<PreferenceStore, PreferencePublisher<Key>>
+    
+    private let keyPath: PrefKeyPath
+    @StateObject private var observer: Observer
+    
+    public init(_ keyPath: PrefKeyPath) {
+        self.keyPath = keyPath
+        self._observer = StateObject(wrappedValue: Observer(keyPath: keyPath))
+    }
+    
+    public var wrappedValue: Key.Value {
+        Preferences.shared.getValue(preferenceKeyPath: keyPath)
+    }
+    
+    @MainActor
+    private class Observer: ObservableObject {
+        private var cancellable: AnyCancellable?
+        
+        init(keyPath: PrefKeyPath) {
+            cancellable = Preferences.shared[keyPath: keyPath].sink { [unowned self] _ in
+                self.objectWillChange.send()
+            }
+        }
+    }
+}

Packages/UserAccounts/Package.swift

@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
     name: "UserAccounts",
     platforms: [
-        .iOS(.v15),
+        .iOS(.v16),
     ],
     products: [
         // Products define the executables and libraries a package produces, and make them visible to other packages.

ShareExtension/ShareMastodonContext.swift

@@ -83,4 +83,8 @@ final class ShareMastodonContext: ComposeMastodonContext, ObservableObject, Send
     
     func storeCreatedStatus(_ status: Status) {
     }
+    
+    func fetchStatus(id: String) -> (any StatusProtocol)? {
+        return nil
+    }
 }

Tusker.xcodeproj/project.pbxproj

@@ -141,7 +141,6 @@
 		D64B96812BC3279D002C8990 /* PrefsAccountView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D64B96802BC3279D002C8990 /* PrefsAccountView.swift */; };
 		D64B96842BC3893C002C8990 /* PushSubscriptionView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D64B96832BC3893C002C8990 /* PushSubscriptionView.swift */; };
 		D64D0AB12128D9AE005A6F37 /* OnboardingViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D64D0AB02128D9AE005A6F37 /* OnboardingViewController.swift */; };
-		D64D8CA92463B494006B0BAA /* MultiThreadDictionary.swift in Sources */ = {isa = PBXBuildFile; fileRef = D64D8CA82463B494006B0BAA /* MultiThreadDictionary.swift */; };
 		D651C5B42915B00400236EF6 /* ProfileFieldsView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D651C5B32915B00400236EF6 /* ProfileFieldsView.swift */; };
 		D6531DEE246B81C9000F9538 /* GifvPlayerView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6531DED246B81C9000F9538 /* GifvPlayerView.swift */; };
 		D6538945214D6D7500E3CEFC /* TableViewSwipeActionProvider.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6538944214D6D7500E3CEFC /* TableViewSwipeActionProvider.swift */; };
@@ -204,16 +203,20 @@
 		D691771729A710520054D7EF /* ProfileNoContentCollectionViewCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = D691771629A710520054D7EF /* ProfileNoContentCollectionViewCell.swift */; };
 		D691771929A7B8820054D7EF /* ProfileHeaderMovedOverlayView.swift in Sources */ = {isa = PBXBuildFile; fileRef = D691771829A7B8820054D7EF /* ProfileHeaderMovedOverlayView.swift */; };
 		D691772E29AA5D420054D7EF /* UserActivityHandlingContext.swift in Sources */ = {isa = PBXBuildFile; fileRef = D691772D29AA5D420054D7EF /* UserActivityHandlingContext.swift */; };
+		D69261232BB3AEFB0023152C /* VideoOverlayViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D69261222BB3AEFB0023152C /* VideoOverlayViewController.swift */; };
 		D69261272BB3BA610023152C /* Box.swift in Sources */ = {isa = PBXBuildFile; fileRef = D69261262BB3BA610023152C /* Box.swift */; };
 		D6934F2C2BA7AD32002B1C8D /* GalleryVC in Frameworks */ = {isa = PBXBuildFile; productRef = D6934F2B2BA7AD32002B1C8D /* GalleryVC */; };
 		D6934F2E2BA7AEF9002B1C8D /* StatusAttachmentsGalleryDataSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F2D2BA7AEF9002B1C8D /* StatusAttachmentsGalleryDataSource.swift */; };
-		D6934F302BA7AF91002B1C8D /* GrayscalableImageGalleryContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F2F2BA7AF91002B1C8D /* GrayscalableImageGalleryContentViewController.swift */; };
+		D6934F302BA7AF91002B1C8D /* ImageGalleryContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F2F2BA7AF91002B1C8D /* ImageGalleryContentViewController.swift */; };
+		D6934F322BA7E43E002B1C8D /* LoadingGalleryContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F312BA7E43E002B1C8D /* LoadingGalleryContentViewController.swift */; };
 		D6934F342BA8D65A002B1C8D /* ImageGalleryDataSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F332BA8D65A002B1C8D /* ImageGalleryDataSource.swift */; };
 		D6934F362BA8E020002B1C8D /* GifvGalleryContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F352BA8E020002B1C8D /* GifvGalleryContentViewController.swift */; };
 		D6934F382BA8E2B7002B1C8D /* GifvController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F372BA8E2B7002B1C8D /* GifvController.swift */; };
-		D6934F3C2BAA0F80002B1C8D /* GrayscalableVideoGalleryContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F3B2BAA0F80002B1C8D /* GrayscalableVideoGalleryContentViewController.swift */; };
+		D6934F3A2BA8F3D7002B1C8D /* FallbackGalleryContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F392BA8F3D7002B1C8D /* FallbackGalleryContentViewController.swift */; };
+		D6934F3C2BAA0F80002B1C8D /* VideoGalleryContentViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F3B2BAA0F80002B1C8D /* VideoGalleryContentViewController.swift */; };
 		D6934F3E2BAA19D5002B1C8D /* ImageActivityItemSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F3D2BAA19D5002B1C8D /* ImageActivityItemSource.swift */; };
 		D6934F402BAA19EC002B1C8D /* VideoActivityItemSource.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F3F2BAA19EC002B1C8D /* VideoActivityItemSource.swift */; };
+		D6934F422BAC7D6E002B1C8D /* VideoControlsViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6934F412BAC7D6E002B1C8D /* VideoControlsViewController.swift */; };
 		D693A72825CF282E003A14E2 /* TrendingHashtagsViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D693A72725CF282E003A14E2 /* TrendingHashtagsViewController.swift */; };
 		D693DE5723FE1A6A0061E07D /* EnhancedNavigationViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D693DE5623FE1A6A0061E07D /* EnhancedNavigationViewController.swift */; };
 		D693DE5923FE24310061E07D /* InteractivePushTransition.swift in Sources */ = {isa = PBXBuildFile; fileRef = D693DE5823FE24300061E07D /* InteractivePushTransition.swift */; };
@@ -333,7 +336,7 @@
 		D6D79F592A13293200AB2315 /* BackgroundManager.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6D79F582A13293200AB2315 /* BackgroundManager.swift */; };
 		D6D94955298963A900C59229 /* Colors.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6D94954298963A900C59229 /* Colors.swift */; };
 		D6D9498D298CBB4000C59229 /* TrendingStatusCollectionViewCell.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6D9498C298CBB4000C59229 /* TrendingStatusCollectionViewCell.swift */; };
-		D6D9498F298EB79400C59229 /* CopyableLable.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6D9498E298EB79400C59229 /* CopyableLable.swift */; };
+		D6D9498F298EB79400C59229 /* CopyableLabel.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6D9498E298EB79400C59229 /* CopyableLabel.swift */; };
 		D6DD8FFD298495A8002AD3FD /* LogoutService.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6DD8FFC298495A8002AD3FD /* LogoutService.swift */; };
 		D6DD8FFF2984D327002AD3FD /* BookmarksViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6DD8FFE2984D327002AD3FD /* BookmarksViewController.swift */; };
 		D6DD996B2998611A0015C962 /* SuggestedProfilesViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = D6DD996A2998611A0015C962 /* SuggestedProfilesViewController.swift */; };
@@ -568,7 +571,6 @@
 		D64B96802BC3279D002C8990 /* PrefsAccountView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PrefsAccountView.swift; sourceTree = "<group>"; };
 		D64B96832BC3893C002C8990 /* PushSubscriptionView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = PushSubscriptionView.swift; sourceTree = "<group>"; };
 		D64D0AB02128D9AE005A6F37 /* OnboardingViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = OnboardingViewController.swift; sourceTree = "<group>"; };
-		D64D8CA82463B494006B0BAA /* MultiThreadDictionary.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MultiThreadDictionary.swift; sourceTree = "<group>"; };
 		D651C5B32915B00400236EF6 /* ProfileFieldsView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProfileFieldsView.swift; sourceTree = "<group>"; };
 		D6531DED246B81C9000F9538 /* GifvPlayerView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GifvPlayerView.swift; sourceTree = "<group>"; };
 		D6538944214D6D7500E3CEFC /* TableViewSwipeActionProvider.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TableViewSwipeActionProvider.swift; sourceTree = "<group>"; };
@@ -635,15 +637,19 @@
 		D691771629A710520054D7EF /* ProfileNoContentCollectionViewCell.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProfileNoContentCollectionViewCell.swift; sourceTree = "<group>"; };
 		D691771829A7B8820054D7EF /* ProfileHeaderMovedOverlayView.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ProfileHeaderMovedOverlayView.swift; sourceTree = "<group>"; };
 		D691772D29AA5D420054D7EF /* UserActivityHandlingContext.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = UserActivityHandlingContext.swift; sourceTree = "<group>"; };
+		D69261222BB3AEFB0023152C /* VideoOverlayViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VideoOverlayViewController.swift; sourceTree = "<group>"; };
 		D69261262BB3BA610023152C /* Box.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Box.swift; sourceTree = "<group>"; };
 		D6934F2D2BA7AEF9002B1C8D /* StatusAttachmentsGalleryDataSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = StatusAttachmentsGalleryDataSource.swift; sourceTree = "<group>"; };
-		D6934F2F2BA7AF91002B1C8D /* GrayscalableImageGalleryContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GrayscalableImageGalleryContentViewController.swift; sourceTree = "<group>"; };
+		D6934F2F2BA7AF91002B1C8D /* ImageGalleryContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ImageGalleryContentViewController.swift; sourceTree = "<group>"; };
+		D6934F312BA7E43E002B1C8D /* LoadingGalleryContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LoadingGalleryContentViewController.swift; sourceTree = "<group>"; };
 		D6934F332BA8D65A002B1C8D /* ImageGalleryDataSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ImageGalleryDataSource.swift; sourceTree = "<group>"; };
 		D6934F352BA8E020002B1C8D /* GifvGalleryContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GifvGalleryContentViewController.swift; sourceTree = "<group>"; };
 		D6934F372BA8E2B7002B1C8D /* GifvController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GifvController.swift; sourceTree = "<group>"; };
-		D6934F3B2BAA0F80002B1C8D /* GrayscalableVideoGalleryContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = GrayscalableVideoGalleryContentViewController.swift; sourceTree = "<group>"; };
+		D6934F392BA8F3D7002B1C8D /* FallbackGalleryContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = FallbackGalleryContentViewController.swift; sourceTree = "<group>"; };
+		D6934F3B2BAA0F80002B1C8D /* VideoGalleryContentViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VideoGalleryContentViewController.swift; sourceTree = "<group>"; };
 		D6934F3D2BAA19D5002B1C8D /* ImageActivityItemSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = ImageActivityItemSource.swift; sourceTree = "<group>"; };
 		D6934F3F2BAA19EC002B1C8D /* VideoActivityItemSource.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VideoActivityItemSource.swift; sourceTree = "<group>"; };
+		D6934F412BAC7D6E002B1C8D /* VideoControlsViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = VideoControlsViewController.swift; sourceTree = "<group>"; };
 		D693A72725CF282E003A14E2 /* TrendingHashtagsViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TrendingHashtagsViewController.swift; sourceTree = "<group>"; };
 		D693DE5623FE1A6A0061E07D /* EnhancedNavigationViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = EnhancedNavigationViewController.swift; sourceTree = "<group>"; };
 		D693DE5823FE24300061E07D /* InteractivePushTransition.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = InteractivePushTransition.swift; sourceTree = "<group>"; };
@@ -770,7 +776,7 @@
 		D6D79F582A13293200AB2315 /* BackgroundManager.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BackgroundManager.swift; sourceTree = "<group>"; };
 		D6D94954298963A900C59229 /* Colors.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Colors.swift; sourceTree = "<group>"; };
 		D6D9498C298CBB4000C59229 /* TrendingStatusCollectionViewCell.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = TrendingStatusCollectionViewCell.swift; sourceTree = "<group>"; };
-		D6D9498E298EB79400C59229 /* CopyableLable.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CopyableLable.swift; sourceTree = "<group>"; };
+		D6D9498E298EB79400C59229 /* CopyableLabel.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = CopyableLabel.swift; sourceTree = "<group>"; };
 		D6DD8FFC298495A8002AD3FD /* LogoutService.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LogoutService.swift; sourceTree = "<group>"; };
 		D6DD8FFE2984D327002AD3FD /* BookmarksViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BookmarksViewController.swift; sourceTree = "<group>"; };
 		D6DD996A2998611A0015C962 /* SuggestedProfilesViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SuggestedProfilesViewController.swift; sourceTree = "<group>"; };
@@ -893,9 +899,13 @@
 			children = (
 				D6934F2D2BA7AEF9002B1C8D /* StatusAttachmentsGalleryDataSource.swift */,
 				D6934F332BA8D65A002B1C8D /* ImageGalleryDataSource.swift */,
-				D6934F2F2BA7AF91002B1C8D /* GrayscalableImageGalleryContentViewController.swift */,
+				D6934F312BA7E43E002B1C8D /* LoadingGalleryContentViewController.swift */,
+				D6934F2F2BA7AF91002B1C8D /* ImageGalleryContentViewController.swift */,
 				D6934F352BA8E020002B1C8D /* GifvGalleryContentViewController.swift */,
-				D6934F3B2BAA0F80002B1C8D /* GrayscalableVideoGalleryContentViewController.swift */,
+				D6934F3B2BAA0F80002B1C8D /* VideoGalleryContentViewController.swift */,
+				D69261222BB3AEFB0023152C /* VideoOverlayViewController.swift */,
+				D6934F412BAC7D6E002B1C8D /* VideoControlsViewController.swift */,
+				D6934F392BA8F3D7002B1C8D /* FallbackGalleryContentViewController.swift */,
 			);
 			path = Gallery;
 			sourceTree = "<group>";
@@ -1478,7 +1488,7 @@
 				D6ADB6EF28ED1F25009924AB /* CachedImageView.swift */,
 				D6895DC328D65342006341DA /* ConfirmReblogStatusPreviewView.swift */,
 				D620483523D38075008A63EF /* ContentTextView.swift */,
-				D6D9498E298EB79400C59229 /* CopyableLable.swift */,
+				D6D9498E298EB79400C59229 /* CopyableLabel.swift */,
 				D6E426B225337C7000C02E1C /* CustomEmojiImageView.swift */,
 				D6969E9F240C8384002843CE /* EmojiLabel.swift */,
 				D61F75B8293C15A000C0B37F /* ZeroHeightCollectionViewCell.swift */,
@@ -1615,7 +1625,6 @@
 				D6DEBA8C2B6579830008629A /* MainThreadBox.swift */,
 				D6B81F432560390300F6E31D /* MenuController.swift */,
 				D6CF5B842AC7C56F00F15D83 /* MultiColumnCollectionViewLayout.swift */,
-				D64D8CA82463B494006B0BAA /* MultiThreadDictionary.swift */,
 				D6945C2E23AC47C3005C403C /* SavedDataManager.swift */,
 				D61F759E29385AD800C0B37F /* SemiCaseSensitiveComparator.swift */,
 				D6895DE828D962C2006341DA /* TimelineLikeController.swift */,
@@ -2113,6 +2122,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				D6934F422BAC7D6E002B1C8D /* VideoControlsViewController.swift in Sources */,
 				0427033A22B31269000D31B6 /* AdvancedPrefsView.swift in Sources */,
 				D6C3F4F5298ED0890009FCFF /* LocalPredicateStatusesViewController.swift in Sources */,
 				D691771729A710520054D7EF /* ProfileNoContentCollectionViewCell.swift in Sources */,
@@ -2159,7 +2169,8 @@
 				D6A4DCCC2553667800D9DE31 /* FastAccountSwitcherViewController.swift in Sources */,
 				D627944F23A9C99800D38C68 /* EditListAccountsViewController.swift in Sources */,
 				D6945C3423AC6431005C403C /* AddSavedHashtagViewController.swift in Sources */,
-				D6934F3C2BAA0F80002B1C8D /* GrayscalableVideoGalleryContentViewController.swift in Sources */,
+				D69261232BB3AEFB0023152C /* VideoOverlayViewController.swift in Sources */,
+				D6934F3C2BAA0F80002B1C8D /* VideoGalleryContentViewController.swift in Sources */,
 				D6F6A552291F098700F496A8 /* RenameListService.swift in Sources */,
 				D62D2426217ABF63005076CC /* UserActivityType.swift in Sources */,
 				D698F46B2BD079F00054DB14 /* AnnouncementListRow.swift in Sources */,
@@ -2179,6 +2190,7 @@
 				D6D94955298963A900C59229 /* Colors.swift in Sources */,
 				D6945C3823AC739F005C403C /* InstanceTimelineViewController.swift in Sources */,
 				D625E4822588262A0074BB2B /* DraggableTableViewCell.swift in Sources */,
+				D6934F322BA7E43E002B1C8D /* LoadingGalleryContentViewController.swift in Sources */,
 				D68E525B24A3D77E0054355A /* TuskerRootViewController.swift in Sources */,
 				D62D2422217AA7E1005076CC /* UserActivityManager.swift in Sources */,
 				D64A50482C739DEA009D7193 /* BaseMainTabBarViewController.swift in Sources */,
@@ -2206,6 +2218,7 @@
 				D630C3CC2BC5FD4600208903 /* GetAuthorizationTokenService.swift in Sources */,
 				D61DC84B28F4FD2000B82C6E /* ProfileHeaderCollectionViewCell.swift in Sources */,
 				D61A45E828DF477D002BE511 /* LoadingCollectionViewCell.swift in Sources */,
+				D6934F3A2BA8F3D7002B1C8D /* FallbackGalleryContentViewController.swift in Sources */,
 				D67B506D250B291200FAECFB /* BlurHashDecode.swift in Sources */,
 				D68A76EC295369A8001DA1B3 /* AboutView.swift in Sources */,
 				04DACE8E212CC7CC009840C4 /* ImageCache.swift in Sources */,
@@ -2290,7 +2303,7 @@
 				D61ABEFE28F1C92600B29151 /* FavoriteService.swift in Sources */,
 				D61F75AB293AF11400C0B37F /* FilterKeywordMO.swift in Sources */,
 				D65B4B5A29720AB000DABDFB /* ReportStatusView.swift in Sources */,
-				D6D9498F298EB79400C59229 /* CopyableLable.swift in Sources */,
+				D6D9498F298EB79400C59229 /* CopyableLabel.swift in Sources */,
 				D6333B792139AEFD00CE884A /* Date+TimeAgo.swift in Sources */,
 				D6D706A029466649000827ED /* ScrollingSegmentedControl.swift in Sources */,
 				D686BBE324FBF8110068E6AA /* WrappedProgressView.swift in Sources */,
@@ -2328,7 +2341,7 @@
 				D61A45EA28DF51EE002BE511 /* TimelineLikeCollectionViewController.swift in Sources */,
 				D64D0AB12128D9AE005A6F37 /* OnboardingViewController.swift in Sources */,
 				D64A50BE2C752247009D7193 /* AdaptableNavigationController.swift in Sources */,
-				D6934F302BA7AF91002B1C8D /* GrayscalableImageGalleryContentViewController.swift in Sources */,
+				D6934F302BA7AF91002B1C8D /* ImageGalleryContentViewController.swift in Sources */,
 				D6934F3E2BAA19D5002B1C8D /* ImageActivityItemSource.swift in Sources */,
 				D67C1795266D57D10070F250 /* FastAccountSwitcherIndicatorView.swift in Sources */,
 				D61F75962937037800C0B37F /* ToggleFollowHashtagService.swift in Sources */,
@@ -2374,7 +2387,6 @@
 				D62E9987279D094F00C26176 /* StatusMetaIndicatorsView.swift in Sources */,
 				D6BEA247291A0F2D002F4D01 /* Duckable+Root.swift in Sources */,
 				D6C1B2082545D1EC00DAAA66 /* StatusCardView.swift in Sources */,
-				D64D8CA92463B494006B0BAA /* MultiThreadDictionary.swift in Sources */,
 				D630C3CA2BC59FF500208903 /* MastodonController+Push.swift in Sources */,
 				D6F6A554291F0D9600F496A8 /* DeleteListService.swift in Sources */,
 				D68E6F5F253C9B2D001A1B4C /* BaseEmojiLabel.swift in Sources */,
@@ -2531,6 +2543,7 @@
 				INFOPLIST_FILE = NotificationExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = NotificationExtension;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "Copyright © 2024 Shadowfacts. All rights reserved.";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2563,6 +2576,7 @@
 				INFOPLIST_FILE = NotificationExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = NotificationExtension;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "Copyright © 2024 Shadowfacts. All rights reserved.";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2594,6 +2608,7 @@
 				INFOPLIST_FILE = NotificationExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = NotificationExtension;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "Copyright © 2024 Shadowfacts. All rights reserved.";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2684,6 +2699,7 @@
 				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				INFOPLIST_FILE = Tusker/Info.plist;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2727,7 +2743,7 @@
 				ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES;
 				CODE_SIGN_STYLE = Automatic;
 				INFOPLIST_FILE = TuskerUITests/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2750,6 +2766,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				INFOPLIST_FILE = OpenInTusker/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2777,6 +2794,7 @@
 				INFOPLIST_FILE = ShareExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = ShareExtension;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "Copyright © 2023 Shadowfacts. All rights reserved.";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2805,6 +2823,7 @@
 				INFOPLIST_FILE = ShareExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = ShareExtension;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "Copyright © 2023 Shadowfacts. All rights reserved.";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2833,6 +2852,7 @@
 				INFOPLIST_FILE = ShareExtension/Info.plist;
 				INFOPLIST_KEY_CFBundleDisplayName = ShareExtension;
 				INFOPLIST_KEY_NSHumanReadableCopyright = "Copyright © 2023 Shadowfacts. All rights reserved.";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -2988,6 +3008,7 @@
 				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				INFOPLIST_FILE = Tusker/Info.plist;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -3020,6 +3041,7 @@
 				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				INFOPLIST_FILE = Tusker/Info.plist;
 				INFOPLIST_KEY_LSApplicationCategoryType = "public.app-category.social-networking";
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -3084,7 +3106,7 @@
 				ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES;
 				CODE_SIGN_STYLE = Automatic;
 				INFOPLIST_FILE = TuskerUITests/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -3104,7 +3126,7 @@
 				ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = YES;
 				CODE_SIGN_STYLE = Automatic;
 				INFOPLIST_FILE = TuskerUITests/Info.plist;
-				IPHONEOS_DEPLOYMENT_TARGET = 15.0;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -3127,6 +3149,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				INFOPLIST_FILE = OpenInTusker/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
@@ -3151,6 +3174,7 @@
 				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = "$(CURRENT_PROJECT_VERSION)";
 				INFOPLIST_FILE = OpenInTusker/Info.plist;
+				IPHONEOS_DEPLOYMENT_TARGET = 16.0;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",

Tusker/Caching/DiskCache.swift

@@ -8,6 +8,7 @@
 
 import Foundation
 import CryptoKit
+import os
 
 struct DiskCacheTransformer<T> {
     let toData: (T) throws -> Data
@@ -21,7 +22,7 @@ class DiskCache<T> {
     let defaultExpiry: CacheExpiry
     let transformer: DiskCacheTransformer<T>
     
-    private var fileStates = MultiThreadDictionary<String, FileState>()
+    private var fileStates = OSAllocatedUnfairLock(initialState: [String: FileState]())
     
     init(name: String, defaultExpiry: CacheExpiry, transformer: DiskCacheTransformer<T>, fileManager: FileManager = .default) throws {
         self.defaultExpiry = defaultExpiry
@@ -59,7 +60,9 @@ class DiskCache<T> {
     }
     
     private func fileState(forKey key: String) -> FileState {
-        return fileStates[key] ?? .unknown
+        return fileStates.withLock {
+            $0[key] ?? .unknown
+        }
     }
     
     func setObject(_ object: T, forKey key: String) throws {
@@ -68,13 +71,17 @@ class DiskCache<T> {
         guard fileManager.createFile(atPath: path, contents: data, attributes: [.modificationDate: defaultExpiry.date]) else {
             throw Error.couldNotCreateFile
         }
-        fileStates[key] = .exists
+        fileStates.withLock {
+            $0[key] = .exists
+        }
     }
     
     func removeObject(forKey key: String) throws {
         let path = makeFilePath(for: key)
         try fileManager.removeItem(atPath: path)
-        fileStates[key] = .doesNotExist
+        fileStates.withLock {
+            $0[key] = .doesNotExist
+        }
     }
     
     func existsObject(forKey key: String) throws -> Bool {
@@ -105,7 +112,9 @@ class DiskCache<T> {
         }
         guard date.timeIntervalSinceNow >= 0 else {
             try fileManager.removeItem(atPath: path)
-            fileStates[key] = .doesNotExist
+            fileStates.withLock {
+                $0[key] = .doesNotExist
+            }
             throw Error.expired
         }
         

Tusker/CoreData/MastodonCachePersistentStore.swift

@@ -375,14 +375,13 @@ class MastodonCachePersistentStore: NSPersistentCloudKitContainer, @unchecked Se
         }
     }
 
-    func addAll(notifications: [Pachyderm.Notification], in context: NSManagedObjectContext? = nil, completion: (() -> Void)? = nil) {
-        let context = context ?? backgroundContext
-        context.perform {
+    func addAll(notifications: [Pachyderm.Notification], completion: (() -> Void)? = nil) {
+        backgroundContext.perform {
             let statuses = notifications.compactMap { $0.status }
             let accounts = notifications.map { $0.account }
-            statuses.forEach { self.upsert(status: $0, context: context) }
-            accounts.forEach { self.upsert(account: $0, in: context) }
-            self.save(context: context)
+            statuses.forEach { self.upsert(status: $0, context: self.backgroundContext) }
+            accounts.forEach { self.upsert(account: $0, in: self.backgroundContext) }
+            self.save(context: self.backgroundContext)
             completion?()
             statuses.forEach { self.statusSubject.send($0.id) }
             accounts.forEach { self.accountSubject.send($0.id) }

Tusker/CoreData/TimelinePosition.swift

@@ -76,17 +76,10 @@ func fromTimelineKind(_ kind: String) -> Timeline {
     } else if kind == "direct" {
         return .direct
     } else if kind.starts(with: "hashtag:") {
-        return .tag(hashtag: String(trimmingPrefix("hashtag:", of: kind)))
+        return .tag(hashtag: String(kind.trimmingPrefix("hashtag:")))
     } else if kind.starts(with: "list:") {
-        return .list(id: String(trimmingPrefix("list:", of: kind)))
+        return .list(id: String(kind.trimmingPrefix("list:")))
     } else {
         fatalError("invalid timeline kind \(kind)")
     }
 }
-
-// replace with Collection.trimmingPrefix
-@available(iOS, obsoleted: 16.0)
-@available(visionOS 1.0, *)
-private func trimmingPrefix(_ prefix: String, of str: String) -> Substring {
-    return str[str.index(str.startIndex, offsetBy: prefix.count)...]
-}

Tusker/Extensions/View+AppListStyle.swift

@@ -36,19 +36,12 @@ private struct AppGroupedListBackground: ViewModifier {
     }
     
     func body(content: Content) -> some View {
-        if #available(iOS 16.0, *) {
-            if colorScheme == .dark, !pureBlackDarkMode {
-                content
-                    .scrollContentBackground(.hidden)
-                    .background(Color.appGroupedBackground.edgesIgnoringSafeArea(.all))
-            } else {
-                content
-            }
+        if colorScheme == .dark, !pureBlackDarkMode {
+            content
+                .scrollContentBackground(.hidden)
+                .background(Color.appGroupedBackground.edgesIgnoringSafeArea(.all))
         } else {
             content
-                .onAppear {
-                    UITableView.appearance(whenContainedInInstancesOf: [container]).backgroundColor = .appGroupedBackground
-                }
         }
     }
 }
@@ -66,31 +59,3 @@ private struct AppGroupedListRowBackground: ViewModifier {
         }
     }
 }
-
-@propertyWrapper
-private struct PreferenceObserving<Key: TuskerPreferences.PreferenceKey>: DynamicProperty {
-    typealias PrefKeyPath = KeyPath<PreferenceStore, PreferencePublisher<Key>>
-    
-    let keyPath: PrefKeyPath
-    @StateObject private var observer: Observer
-    
-    init(_ keyPath: PrefKeyPath) {
-        self.keyPath = keyPath
-        self._observer = StateObject(wrappedValue: Observer(keyPath: keyPath))
-    }
-    
-    var wrappedValue: Key.Value {
-        Preferences.shared.getValue(preferenceKeyPath: keyPath)
-    }
-    
-    @MainActor
-    private class Observer: ObservableObject {
-        private var cancellable: AnyCancellable?
-        
-        init(keyPath: PrefKeyPath) {
-            cancellable = Preferences.shared[keyPath: keyPath].sink { [unowned self] _ in
-                self.objectWillChange.send()
-            }
-        }
-    }
-}

Tusker/HTMLConverter.swift

@@ -48,14 +48,13 @@ extension HTMLConverter {
             // Converting WebURL to URL is a small but non-trivial expense (since it works by
             // serializing the WebURL as a string and then having Foundation parse it again),
             // so, if available, use the system parser which doesn't require another round trip.
-            if #available(iOS 16.0, macOS 13.0, *),
-               let url = try? URL.ParseStrategy().parse(string) {
+            if let url = try? URL.ParseStrategy().parse(string) {
                 url
             } else if let web = WebURL(string),
                       let url = URL(web) {
                 url
             } else {
-                URL(string: string)
+                nil
             }
         }
         

Tusker/MultiThreadDictionary.swift

@@ -1,104 +0,0 @@
-//
-//  MultiThreadDictionary.swift
-//  Tusker
-//
-//  Created by Shadowfacts on 5/6/20.
-//  Copyright © 2020 Shadowfacts. All rights reserved.
-//
-
-import Foundation
-import os
-
-// once we target iOS 16, replace uses of this with OSAllocatedUnfairLock<[Key: Value]>
-// to make the lock semantics more clear
-@available(iOS, obsoleted: 16.0)
-@available(visionOS 1.0, *)
-final class MultiThreadDictionary<Key: Hashable & Sendable, Value: Sendable>: @unchecked Sendable {
-    #if os(visionOS)
-    private let lock = OSAllocatedUnfairLock(initialState: [Key: Value]())
-    #else
-    private let lock: any Lock<[Key: Value]>
-    #endif
-    
-    init() {
-        #if !os(visionOS)
-        if #available(iOS 16.0, *) {
-            self.lock = OSAllocatedUnfairLock(initialState: [:])
-        } else {
-            self.lock = UnfairLock(initialState: [:])
-        }
-        #endif
-    }
-    
-    subscript(key: Key) -> Value? {
-        get {
-            return lock.withLock { dict in
-                dict[key]
-            }
-        }
-        set(value) {
-            #if os(visionOS)
-            lock.withLock { dict in
-                dict[key] = value
-            }
-            #else
-            _ = lock.withLock { dict in
-                dict[key] = value
-            }
-            #endif
-        }
-    }
-    
-    /// If the result of this function is unused, it is preferable to use `removeValueWithoutReturning` as it executes asynchronously and doesn't block the calling thread.
-    func removeValue(forKey key: Key) -> Value? {
-        return lock.withLock { dict in
-            dict.removeValue(forKey: key)
-        }
-    }
-    
-    func contains(key: Key) -> Bool {
-        return lock.withLock { dict in
-            dict.keys.contains(key)
-        }
-    }
-    
-    // TODO: this should really be throws/rethrows but the stupid type-erased lock makes that not possible
-    func withLock<R>(_ body: @Sendable (inout [Key: Value]) throws -> R) rethrows -> R where R: Sendable {
-        return try lock.withLock { dict in
-            return try body(&dict)
-        }
-    }
-}
-
-#if !os(visionOS)
-// TODO: replace this only with OSAllocatedUnfairLock
-@available(iOS, obsoleted: 16.0)
-fileprivate protocol Lock<State> {
-    associatedtype State
-    func withLock<R>(_ body: @Sendable (inout State) throws -> R) rethrows -> R where R: Sendable
-}
-
-@available(iOS 16.0, *)
-extension OSAllocatedUnfairLock: Lock {
-}
-
-// from http://www.russbishop.net/the-law
-fileprivate class UnfairLock<State>: Lock {
-    private var lock: UnsafeMutablePointer<os_unfair_lock>
-    private var state: State
-    init(initialState: State) {
-        self.state = initialState
-        self.lock = .allocate(capacity: 1)
-        self.lock.initialize(to: os_unfair_lock())
-    }
-    deinit {
-        self.lock.deinitialize(count: 1)
-        self.lock.deallocate()
-    }
-    func withLock<R>(_ body: (inout State) throws -> R) rethrows -> R where R: Sendable {
-        os_unfair_lock_lock(lock)
-        defer { os_unfair_lock_unlock(lock) }
-        return try body(&state)
-    }
-}
-#endif

Tusker/Scenes/MainSceneDelegate.swift

@@ -274,8 +274,7 @@ class MainSceneDelegate: UIResponder, UIWindowSceneDelegate, TuskerSceneDelegate
         } else {
             mainVC = MainSplitViewController(mastodonController: mastodonController)
         }
-        if UIDevice.current.userInterfaceIdiom == .phone,
-           #available(iOS 16.0, *) {
+        if UIDevice.current.userInterfaceIdiom == .phone {
             // TODO: maybe the duckable container should be outside the account switching container
             return DuckableContainerViewController(child: mainVC)
         } else {

Tusker/Screens/Announcements/AddReactionView.swift

@@ -86,7 +86,7 @@ struct AddReactionView: View {
             }
         }
         .navigationViewStyle(.stack)
-        .mediumPresentationDetentIfAvailable()
+        .presentationDetents([.medium, .large])
         .alertWithData("Error Adding Reaction", data: $error, actions: { _ in
             Button("OK") {}
         }, message: { error in
@@ -171,17 +171,6 @@ private struct AddReactionButton<Label: View>: View {
 }
 
 private extension View {
-    @available(iOS, obsoleted: 16.0)
-    @available(visionOS 1.0, *)
-    @ViewBuilder
-    func mediumPresentationDetentIfAvailable() -> some View {
-        if #available(iOS 16.0, *) {
-            self.presentationDetents([.medium, .large])
-        } else {
-            self
-        }
-    }
-    
     @available(iOS, obsoleted: 17.1)
     @available(visionOS 1.0, *)
     @ViewBuilder

Tusker/Screens/Announcements/AnnouncementListRow.swift

@@ -20,14 +20,10 @@ struct AnnouncementListRow: View {
     @State private var isShowingAddReactionSheet = false
     
     var body: some View {
-        if #available(iOS 16.0, *) {
-            mostOfTheBody
-                .alignmentGuide(.listRowSeparatorLeading, computeValue: { dimension in
-                    dimension[.leading]
-                })
-        } else {
-            mostOfTheBody
-        }
+        mostOfTheBody
+            .alignmentGuide(.listRowSeparatorLeading, computeValue: { dimension in
+                dimension[.leading]
+            })
     }
     
     private var mostOfTheBody: some View {
@@ -54,11 +50,7 @@ struct AnnouncementListRow: View {
                         Label {
                             Text("Add Reaction")
                         } icon: {
-                            if #available(iOS 16.0, *) {
-                                Image("face.smiling.badge.plus")
-                            } else {
-                                Image(systemName: "face.smiling")
-                            }
+                            Image("face.smiling.badge.plus")
                         }
                     }
                     .labelStyle(.iconOnly)

Tusker/Screens/Compose/ComposeHostingController.swift

@@ -50,6 +50,10 @@ class ComposeHostingController: UIHostingController<ComposeHostingController.Vie
             emojiImageView: { AnyView(CustomEmojiImageView(emoji: $0)) }
         )
         
+        if let account = mastodonController.account {
+            controller.currentAccount = account
+        }
+        
         self.mastodonController = mastodonController
         
         super.init(rootView: View(mastodonController: mastodonController, controller: controller))
@@ -129,7 +133,6 @@ class ComposeHostingController: UIHostingController<ComposeHostingController.Vie
         let picker = PHPickerViewController(configuration: config)
         picker.delegate = self
         picker.modalPresentationStyle = .pageSheet
-        picker.overrideUserInterfaceStyle = .dark
         // sheet detents don't play nice with PHPickerViewController, see
 //        let sheet = picker.sheetPresentationController!
 //        sheet.detents = [.medium(), .large()]
@@ -151,7 +154,8 @@ class ComposeHostingController: UIHostingController<ComposeHostingController.Vie
         var body: some SwiftUI.View {
             ControllerView(controller: { controller })
                 .task {
-                    if let account = try? await mastodonController.getOwnAccount() {
+                    if controller.currentAccount == nil,
+                       let account = try? await mastodonController.getOwnAccount() {
                         controller.currentAccount = account
                     }
                 }
@@ -185,6 +189,7 @@ extension ComposeHostingController: DuckableViewController {
 }
 #endif
 
+// TODO: don't conform MastodonController to this protocol, use a separate type
 extension MastodonController: ComposeMastodonContext {
     @MainActor
     func searchCachedAccounts(query: String) -> [AccountProtocol] {
@@ -227,6 +232,10 @@ extension MastodonController: ComposeMastodonContext {
     func storeCreatedStatus(_ status: Status) {
         persistentContainer.addOrUpdate(status: status)
     }
+    
+    func fetchStatus(id: String) -> (any StatusProtocol)? {
+        return persistentContainer.status(for: id)
+    }
 }
 
 extension ComposeHostingController: PHPickerViewControllerDelegate {

Tusker/Screens/Conversation/ConversationViewController.swift

@@ -484,11 +484,3 @@ extension ConversationViewController: StatusBarTappableViewController {
         }
     }
 }
-
-extension ConversationViewController: RefreshableViewController {
-    func refresh() {
-        Task {
-            await refreshContext()
-        }
-    }
-}

Tusker/Screens/Customize Timelines/AddHashtagPinnedTimelineView.swift

@@ -9,20 +9,6 @@
 import SwiftUI
 import Pachyderm
 
-@available(iOS, obsoleted: 16.0)
-struct AddHashtagPinnedTimelineRepresentable: UIViewControllerRepresentable {
-    typealias UIViewControllerType = UIHostingController<AddHashtagPinnedTimelineView>
-    
-    @Binding var pinnedTimelines: [PinnedTimeline]
-    
-    func makeUIViewController(context: Context) -> UIHostingController<AddHashtagPinnedTimelineView> {
-        return UIHostingController(rootView: AddHashtagPinnedTimelineView(pinnedTimelines: $pinnedTimelines))
-    }
-    
-    func updateUIViewController(_ uiViewController: UIHostingController<AddHashtagPinnedTimelineView>, context: Context) {
-    }
-}
-
 struct AddHashtagPinnedTimelineView: View {
     @EnvironmentObject private var mastodonController: MastodonController
     @Environment(\.dismiss) private var dismiss
@@ -49,9 +35,6 @@ struct AddHashtagPinnedTimelineView: View {
     var body: some View {
         NavigationView {
             list
-                #if !os(visionOS)
-                .appGroupedListBackground(container: AddHashtagPinnedTimelineRepresentable.UIViewControllerType.self)
-                #endif
                 .listStyle(.grouped)
                 .navigationTitle("Add Hashtag")
                 .navigationBarTitleDisplayMode(.inline)

Tusker/Screens/Customize Timelines/CustomizeTimelinesView.swift

@@ -36,15 +36,8 @@ struct CustomizeTimelinesList: View {
     }
 
     var body: some View {
-        if #available(iOS 16.0, *) {
-            NavigationStack {
-                navigationBody
-            }
-        } else {
-            NavigationView {
-                navigationBody
-            }
-            .navigationViewStyle(.stack)
+        NavigationStack {
+            navigationBody
         }
     }
     

Tusker/Screens/Customize Timelines/EditFilterView.swift

@@ -149,7 +149,7 @@ struct EditFilterView: View {
         }
         .appGroupedListBackground(container: UIHostingController<CustomizeTimelinesList>.self)
         #if !os(visionOS)
-        .scrollDismissesKeyboardInteractivelyIfAvailable()
+        .scrollDismissesKeyboard(.interactively)
         #endif
         .navigationTitle(create ? "Add Filter" : "Edit Filter")
         .navigationBarTitleDisplayMode(.inline)
@@ -226,18 +226,6 @@ private struct FilterContextToggleStyle: ToggleStyle {
     }
 }
 
-private extension View {
-    @available(iOS, obsoleted: 16.0)
-    @ViewBuilder
-    func scrollDismissesKeyboardInteractivelyIfAvailable() -> some View {
-        if #available(iOS 16.0, *) {
-            self.scrollDismissesKeyboard(.interactively)
-        } else {
-            self
-        }
-    }
-}
-
 //struct EditFilterView_Previews: PreviewProvider {
 //    static var previews: some View {
 //        EditFilterView()

Tusker/Screens/Customize Timelines/PinnedTimelinesView.swift

@@ -115,18 +115,8 @@ struct PinnedTimelinesModifier: ViewModifier {
     func body(content: Content) -> some View {
         content
             .sheet(isPresented: $isShowingAddHashtagSheet, content: {
-                #if os(visionOS)
                 AddHashtagPinnedTimelineView(pinnedTimelines: $pinnedTimelines)
                     .edgesIgnoringSafeArea(.bottom)
-                #else
-                if #available(iOS 16.0, *) {
-                    AddHashtagPinnedTimelineView(pinnedTimelines: $pinnedTimelines)
-                        .edgesIgnoringSafeArea(.bottom)
-                } else {
-                    AddHashtagPinnedTimelineRepresentable(pinnedTimelines: $pinnedTimelines)
-                        .edgesIgnoringSafeArea(.bottom)
-                }
-                #endif
             })
             .sheet(isPresented: $isShowingAddInstanceSheet, content: {
                 AddInstancePinnedTimelineView(pinnedTimelines: $pinnedTimelines)

Tusker/Screens/Explore/InlineTrendsViewController.swift

@@ -41,9 +41,7 @@ class InlineTrendsViewController: UIViewController {
 
         navigationItem.searchController = searchController
         navigationItem.hidesSearchBarWhenScrolling = false
-        if #available(iOS 16.0, *) {
-            navigationItem.preferredSearchBarPlacement = .stacked
-        }
+        navigationItem.preferredSearchBarPlacement = .stacked
         
         let trends = TrendsViewController(mastodonController: mastodonController)
         trends.view.translatesAutoresizingMaskIntoConstraints = false

Tusker/Screens/Explore/TrendingLinkCardView.swift

@@ -16,11 +16,15 @@ struct TrendingLinkCardView: View {
     let card: Card
     
     private var imageURL: URL? {
-        card.image.flatMap { URL($0) }
+        if let image = card.image {
+            URL(image)
+        } else {
+            nil
+        }
     }
     
     private var descriptionText: String {
-        let converter = TextConverter(configuration: .init(insertNewlines: false))
+        var converter = TextConverter(configuration: .init(insertNewlines: false))
         return converter.convert(html: card.description)
     }
     

Tusker/Screens/Explore/TrendsViewController.swift

@@ -525,12 +525,12 @@ extension TrendsViewController: UICollectionViewDelegate {
         }
     }
     
-    @available(iOS, obsoleted: 16.0)
-    @available(visionOS 1.0, *)
-    func collectionView(_ collectionView: UICollectionView, contextMenuConfigurationForItemAt indexPath: IndexPath, point: CGPoint) -> UIContextMenuConfiguration? {
-        guard let item = dataSource.itemIdentifier(for: indexPath) else {
+    func collectionView(_ collectionView: UICollectionView, contextMenuConfigurationForItemsAt indexPaths: [IndexPath], point: CGPoint) -> UIContextMenuConfiguration? {
+        guard indexPaths.count == 1,
+              let item = dataSource.itemIdentifier(for: indexPaths[0])  else {
             return nil
         }
+        let indexPath = indexPaths[0]
         
         switch item {
         case .loadingIndicator, .confirmLoadMoreStatuses(_):
@@ -584,15 +584,6 @@ extension TrendsViewController: UICollectionViewDelegate {
         }
     }
     
-    // implementing the highlightPreviewForItemAt method seems to prevent the old, single IndexPath variant of this method from being called on iOS 16
-    @available(iOS 16.0, visionOS 1.0, *)
-    func collectionView(_ collectionView: UICollectionView, contextMenuConfigurationForItemsAt indexPaths: [IndexPath], point: CGPoint) -> UIContextMenuConfiguration? {
-        guard indexPaths.count == 1 else {
-            return nil
-        }
-        return self.collectionView(collectionView, contextMenuConfigurationForItemAt: indexPaths[0], point: point)
-    }
-    
     func collectionView(_ collectionView: UICollectionView, willPerformPreviewActionForMenuWith configuration: UIContextMenuConfiguration, animator: UIContextMenuInteractionCommitAnimating) {
         MenuPreviewHelper.willPerformPreviewAction(animator: animator, presenter: self)
     }

Tusker/Screens/Gallery/FallbackGalleryContentViewController.swift

@@ -1,13 +1,15 @@
 //
 //  FallbackGalleryContentViewController.swift
-//  GalleryVC
+//  Tusker
 //
 //  Created by Shadowfacts on 3/18/24.
 //  Copyright © 2024 Shadowfacts. All rights reserved.
 //
 
 import UIKit
+import GalleryVC
 import QuickLook
+import Pachyderm
 
 private class FallbackGalleryContentViewController: QLPreviewController {
     private let previewItem = GalleryPreviewItem()
@@ -50,40 +52,40 @@ extension FallbackGalleryContentViewController: QLPreviewControllerDataSource {
     }
 }
 
-public class FallbackGalleryNavigationController: UINavigationController, GalleryContentViewController {
-    public init(url: URL) {
+class FallbackGalleryNavigationController: UINavigationController, GalleryContentViewController {
+    init(url: URL) {
         super.init(nibName: nil, bundle: nil)
         self.viewControllers = [FallbackGalleryContentViewController(url: url)]
     }
     
-    public override func viewDidLoad() {
+    override func viewDidLoad() {
         super.viewDidLoad()
         
         container?.disableGalleryScrollAndZoom()
     }
     
-    public required init?(coder aDecoder: NSCoder) {
+    required init?(coder aDecoder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
     
     // MARK: GalleryContentViewController
     
-    public weak var container: (any GalleryContentViewControllerContainer)?
+    weak var container: (any GalleryVC.GalleryContentViewControllerContainer)?
     
-    public var contentSize: CGSize {
+    var contentSize: CGSize {
         .zero
     }
     
-    public var activityItemsForSharing: [Any] {
+    var activityItemsForSharing: [Any] {
         []
     }
     
-    public var caption: String? {
+    var caption: String? {
         nil
     }
     
-    public var presentationAnimation: GalleryContentPresentationAnimation {
-        .fade
+    var canAnimateFromSourceView: Bool {
+        false
     }
 }
 

Tusker/Screens/Gallery/GifvGalleryContentViewController.swift

@@ -69,8 +69,4 @@ class GifvGalleryContentViewController: UIViewController, GalleryContentViewCont
         [VideoActivityItemSource(asset: controller.item.asset, url: url)]
     }
     
-    var presentationAnimation: GalleryContentPresentationAnimation {
-        .fromSourceViewWithoutSnapshot
-    }
-    
 }

Tusker/Screens/Gallery/GrayscalableImageGalleryContentViewController.swift

@@ -1,60 +0,0 @@
-//
-//  GrayscalableImageGalleryContentViewController.swift
-//  Tusker
-//
-//  Created by Shadowfacts on 11/21/24.
-//  Copyright © 2024 Shadowfacts. All rights reserved.
-//
-
-import UIKit
-import TuskerComponents
-import GalleryVC
-
-class GrayscalableImageGalleryContentViewController: GalleryVC.ImageGalleryContentViewController {
-    private let url: URL
-    private let originalImage: UIImage
-    private let originalData: Data?
-    private var isGrayscale = false
-    
-    init(url: URL, caption: String?, originalData: Data?, image: UIImage, gifController: GIFController?) {
-        self.url = url
-        self.originalImage = image
-        self.originalData = originalData
-        
-        super.init(image: image, caption: caption, gifController: gifController)
-        
-        isGrayscale = Preferences.shared.grayscaleImages
-        if isGrayscale {
-            self.image = ImageGrayscalifier.convert(url: url, image: image) ?? image
-        }
-        
-        NotificationCenter.default.addObserver(self, selector: #selector(preferencesChanged), name: .preferencesChanged, object: nil)
-    }
-    
-    @MainActor required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-    
-    @objc private func preferencesChanged() {
-        if isGrayscale != Preferences.shared.grayscaleImages {
-            isGrayscale = Preferences.shared.grayscaleImages
-            let image = if isGrayscale {
-                ImageGrayscalifier.convert(url: url, image: originalImage)
-            } else {
-                originalImage
-            }
-            if let image {
-                self.image = image
-            }
-        }
-    }
-    
-    override var activityItemsForSharing: [Any] {
-        if let data = originalData ?? image.pngData() {
-            return [ImageActivityItemSource(data: data, url: url, image: image)]
-        } else {
-            return []
-        }
-    }
-    
-}

Tusker/Screens/Gallery/GrayscalableVideoGalleryContentViewController.swift

@@ -1,83 +0,0 @@
-//
-//  GrayscalableVideoGalleryContentViewController.swift
-//  Tusker
-//
-//  Created by Shadowfacts on 11/21/24.
-//  Copyright © 2024 Shadowfacts. All rights reserved.
-//
-
-import UIKit
-import GalleryVC
-import AVFoundation
-
-class GrayscalableVideoGalleryContentViewController: GalleryVC.VideoGalleryContentViewController {
-    private var audioSessionToken: AudioSessionCoordinator.Token?
-    private var isGrayscale: Bool
-    private var isFirstAppearance = true
-
-    override init(url: URL, caption: String?) {
-        self.isGrayscale = Preferences.shared.grayscaleImages
-        
-        super.init(url: url, caption: caption)
-        
-        NotificationCenter.default.addObserver(self, selector: #selector(preferencesChanged), name: .preferencesChanged, object: nil)
-    }
-    
-    @MainActor required init?(coder: NSCoder) {
-        fatalError("init(coder:) has not been implemented")
-    }
-    
-    override class func createItem(asset: AVAsset) -> AVPlayerItem {
-        let item = AVPlayerItem(asset: asset)
-        if Preferences.shared.grayscaleImages {
-            #if os(visionOS)
-            #warning("Use async AVVideoComposition CIFilter initializer")
-            #else
-            let filter = CIFilter(name: "CIColorMonochrome")!
-            filter.setValue(CIColor(red: 0.85, green: 0.85, blue: 0.85), forKey: "inputColor")
-            filter.setValue(1.0, forKey: "inputIntensity")
-            
-            item.videoComposition = AVVideoComposition(asset: asset, applyingCIFiltersWithHandler: { request in
-                filter.setValue(request.sourceImage, forKey: "inputImage")
-                request.finish(with: filter.outputImage!, context: nil)
-            })
-            #endif
-        }
-        return item
-    }
-    
-    @objc private func preferencesChanged() {
-        if isGrayscale != Preferences.shared.grayscaleImages {
-            let isPlaying = player.rate > 0
-            isGrayscale = Preferences.shared.grayscaleImages
-            replaceCurrentItem(with: Self.createItem(asset: item.asset))
-            if isPlaying {
-                player.play()
-            }
-        }
-    }
-    
-    override func galleryContentDidAppear() {
-        super.galleryContentDidAppear()
-        
-        let wasFirstAppearance = isFirstAppearance
-        isFirstAppearance = false
-        
-        audioSessionToken = AudioSessionCoordinator.shared.beginPlayback(mode: .video) {
-            if wasFirstAppearance {
-                DispatchQueue.main.async {
-                    self.player.play()
-                }
-            }
-        }
-    }
-    
-    override func galleryContentWillDisappear() {
-        super.galleryContentWillDisappear()
-        
-        if let audioSessionToken {
-            AudioSessionCoordinator.shared.endPlayback(token: audioSessionToken)
-        }
-    }
-    
-}

Tusker/Screens/Gallery/ImageGalleryContentViewController.swift

@@ -1,22 +1,22 @@
 //
 //  ImageGalleryContentViewController.swift
-//  GalleryVC
+//  Tusker
 //
 //  Created by Shadowfacts on 3/17/24.
 //  Copyright © 2024 Shadowfacts. All rights reserved.
 //
 
 import UIKit
+import GalleryVC
+import Pachyderm
 import TuskerComponents
 @preconcurrency import VisionKit
 
-open class ImageGalleryContentViewController: UIViewController, GalleryContentViewController {
-    public let caption: String?
-    public var image: UIImage {
-        didSet {
-            imageView?.image = image
-        }
-    }
+class ImageGalleryContentViewController: UIViewController, GalleryContentViewController {
+    let url: URL
+    let caption: String?
+    let originalData: Data?
+    let image: UIImage
     let gifController: GIFController?
     
     private var imageView: GIFImageView!
@@ -27,8 +27,12 @@ open class ImageGalleryContentViewController: UIViewController, GalleryContentVi
     @available(iOS 16.0, macCatalyst 17.0, *)
     private var analysisInteraction: ImageAnalysisInteraction? { _analysisInteraction as? ImageAnalysisInteraction }
     
-    public init(image: UIImage, caption: String?, gifController: GIFController?) {
+    private var isGrayscale = false
+    
+    init(url: URL, caption: String?, originalData: Data?, image: UIImage, gifController: GIFController?) {
+        self.url = url
         self.caption = caption
+        self.originalData = originalData
         self.image = image
         self.gifController = gifController
         
@@ -37,14 +41,21 @@ open class ImageGalleryContentViewController: UIViewController, GalleryContentVi
         preferredContentSize = image.size
     }
     
-    public required init?(coder: NSCoder) {
+    required init?(coder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
     
-    public override func viewDidLoad() {
+    override func viewDidLoad() {
         super.viewDidLoad()
         
-        imageView = GIFImageView(image: image)
+        isGrayscale = Preferences.shared.grayscaleImages
+        let maybeGrayscaleImage = if isGrayscale {
+            ImageGrayscalifier.convert(url: url, image: image) ?? image
+        } else {
+            image
+        }
+        
+        imageView = GIFImageView(image: maybeGrayscaleImage)
         imageView.translatesAutoresizingMaskIntoConstraints = false
         imageView.contentMode = .scaleAspectFill
         imageView.isUserInteractionEnabled = true
@@ -75,9 +86,11 @@ open class ImageGalleryContentViewController: UIViewController, GalleryContentVi
                 }
             }
         }
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(preferencesChanged), name: .preferencesChanged, object: nil)
     }
     
-    public override func viewWillAppear(_ animated: Bool) {
+    override func viewWillAppear(_ animated: Bool) {
         super.viewWillAppear(animated)
         
         if let gifController {
@@ -85,23 +98,37 @@ open class ImageGalleryContentViewController: UIViewController, GalleryContentVi
         }
     }
     
+    @objc private func preferencesChanged() {
+        if isGrayscale != Preferences.shared.grayscaleImages {
+            isGrayscale = Preferences.shared.grayscaleImages
+            let image = if isGrayscale {
+                ImageGrayscalifier.convert(url: url, image: image)
+            } else {
+                image
+            }
+            if let image {
+                imageView.image = image
+            }
+        }
+    }
+    
     // MARK: GalleryContentViewController
     
-    public weak var container: (any GalleryContentViewControllerContainer)?
+    weak var container: (any GalleryVC.GalleryContentViewControllerContainer)?
     
-    public var contentSize: CGSize {
+    var contentSize: CGSize {
         image.size
     }
     
-    open var activityItemsForSharing: [Any] {
-        return [image]
+    var activityItemsForSharing: [Any] {
+        if let data = originalData ?? image.pngData() {
+            return [ImageActivityItemSource(data: data, url: url, image: image)]
+        } else {
+            return []
+        }
     }
     
-    public var presentationAnimation: GalleryContentPresentationAnimation {
-        gifController != nil ? .fromSourceViewWithoutSnapshot : .fromSourceView
-    }
-    
-    public func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool) {
+    func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool) {
         if #available(iOS 16.0, macCatalyst 17.0, *),
            let analysisInteraction {
             analysisInteraction.setSupplementaryInterfaceHidden(!visible, animated: animated)
@@ -111,7 +138,7 @@ open class ImageGalleryContentViewController: UIViewController, GalleryContentVi
 
 @available(iOS 16.0, macCatalyst 17.0, *)
 extension ImageGalleryContentViewController: ImageAnalysisInteractionDelegate {
-    public func interaction(_ interaction: ImageAnalysisInteraction, shouldBeginAt point: CGPoint, for interactionType: ImageAnalysisInteraction.InteractionTypes) -> Bool {
+    func interaction(_ interaction: ImageAnalysisInteraction, shouldBeginAt point: CGPoint, for interactionType: ImageAnalysisInteraction.InteractionTypes) -> Bool {
         return container?.galleryControlsVisible ?? true
     }
 }

Tusker/Screens/Gallery/ImageGalleryDataSource.swift

@@ -34,7 +34,7 @@ class ImageGalleryDataSource: GalleryDataSource {
                 } else {
                     nil
                 }
-            return GrayscalableImageGalleryContentViewController(
+            return ImageGalleryContentViewController(
                 url: url,
                 caption: nil,
                 originalData: entry.data,
@@ -52,7 +52,7 @@ class ImageGalleryDataSource: GalleryDataSource {
                         } else {
                             nil
                         }
-                    return GrayscalableImageGalleryContentViewController(
+                    return ImageGalleryContentViewController(
                         url: self.url,
                         caption: nil,
                         originalData: data,

Tusker/Screens/Gallery/LoadingGalleryContentViewController.swift

@@ -7,42 +7,43 @@
 //
 
 import UIKit
+import GalleryVC
 
-public class LoadingGalleryContentViewController: UIViewController, GalleryContentViewController {
+class LoadingGalleryContentViewController: UIViewController, GalleryContentViewController {
     private let fallbackCaption: String?
     private let provider: () async -> (any GalleryContentViewController)?
     private var wrapped: (any GalleryContentViewController)!
     
-    public weak var container: GalleryContentViewControllerContainer?
+    weak var container: GalleryContentViewControllerContainer?
     
-    public var contentSize: CGSize {
+    var contentSize: CGSize {
         wrapped?.contentSize ?? .zero
     }
     
-    public var activityItemsForSharing: [Any] {
+    var activityItemsForSharing: [Any] {
         wrapped?.activityItemsForSharing ?? []
     }
     
-    public var caption: String? {
+    var caption: String? {
         wrapped?.caption ?? fallbackCaption
     }
     
-    public var presentationAnimation: GalleryContentPresentationAnimation {
-        wrapped?.presentationAnimation ?? .fade
+    var canAnimateFromSourceView: Bool {
+        wrapped?.canAnimateFromSourceView ?? true
     }
     
-    public init(caption: String?, provider: @escaping () async -> (any GalleryContentViewController)?) {
+    init(caption: String?, provider: @escaping () async -> (any GalleryContentViewController)?) {
         self.fallbackCaption = caption
         self.provider = provider
         
         super.init(nibName: nil, bundle: nil)
     }
     
-    public required init?(coder: NSCoder) {
+    required init?(coder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
     
-    public override func viewDidLoad() {
+    override func viewDidLoad() {
         super.viewDidLoad()
         
         container?.setGalleryContentLoading(true)
@@ -80,7 +81,7 @@ public class LoadingGalleryContentViewController: UIViewController, GalleryConte
         
         let label = UILabel()
         label.text = "Error Loading"
-        label.font = UIFont(descriptor: .preferredFontDescriptor(withTextStyle: .title1).withSymbolicTraits(.traitBold)!, size: 0)
+        label.font = .preferredFont(forTextStyle: .title1).withTraits(.traitBold)!
         label.textColor = .secondaryLabel
         label.adjustsFontForContentSizeCategory = true
         
@@ -101,15 +102,15 @@ public class LoadingGalleryContentViewController: UIViewController, GalleryConte
         ])
     }
     
-    public func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool) {
+    func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool) {
         wrapped?.setControlsVisible(visible, animated: animated, dueToUserInteraction: dueToUserInteraction)
     }
     
-    public func galleryContentDidAppear() {
+    func galleryContentDidAppear() {
         wrapped?.galleryContentDidAppear()
     }
     
-    public func galleryContentWillDisappear() {
+    func galleryContentWillDisappear() {
         wrapped?.galleryContentWillDisappear()
     }
     

Tusker/Screens/Gallery/StatusAttachmentsGalleryDataSource.swift

@@ -33,7 +33,7 @@ class StatusAttachmentsGalleryDataSource: GalleryDataSource {
         case .image:
             if let view = attachmentView(for: attachment),
                let image = view.attachmentImage {
-                return GrayscalableImageGalleryContentViewController(
+                return ImageGalleryContentViewController(
                     url: attachment.url,
                     caption: attachment.description,
                     originalData: view.originalData,
@@ -49,7 +49,7 @@ class StatusAttachmentsGalleryDataSource: GalleryDataSource {
                     } else {
                         nil
                     }
-                return GrayscalableImageGalleryContentViewController(
+                return ImageGalleryContentViewController(
                     url: attachment.url,
                     caption: attachment.description,
                     originalData: entry.data,
@@ -68,7 +68,7 @@ class StatusAttachmentsGalleryDataSource: GalleryDataSource {
                             } else {
                                 nil
                             }
-                        return GrayscalableImageGalleryContentViewController(
+                        return ImageGalleryContentViewController(
                             url: attachment.url,
                             caption: attachment.description,
                             originalData: data,
@@ -91,10 +91,10 @@ class StatusAttachmentsGalleryDataSource: GalleryDataSource {
                 }
             return GifvGalleryContentViewController(controller: controller, url: attachment.url, caption: attachment.description)
         case .video:
-            return GrayscalableVideoGalleryContentViewController(url: attachment.url, caption: attachment.description)
+            return VideoGalleryContentViewController(url: attachment.url, caption: attachment.description)
         case .audio:
             // TODO: use separate content VC with audio visualization?
-            return GrayscalableVideoGalleryContentViewController(url: attachment.url, caption: attachment.description)
+            return VideoGalleryContentViewController(url: attachment.url, caption: attachment.description)
         case .unknown:
             return LoadingGalleryContentViewController(caption: nil) {
                 do {

Tusker/Screens/Gallery/VideoControlsViewController.swift

@@ -1,6 +1,6 @@
 //
 //  VideoControlsViewController.swift
-//  GalleryVC
+//  Tusker
 //
 //  Created by Shadowfacts on 3/21/24.
 //  Copyright © 2024 Shadowfacts. All rights reserved.
@@ -9,15 +9,6 @@
 import UIKit
 import AVFoundation
 
-@propertyWrapper
-final class Box<T> {
-    var wrappedValue: T
-    
-    init(wrappedValue: T) {
-        self.wrappedValue = wrappedValue
-    }
-}
-
 class VideoControlsViewController: UIViewController {
     private static let formatter: DateComponentsFormatter = {
         let f = DateComponentsFormatter()
@@ -27,49 +18,33 @@ class VideoControlsViewController: UIViewController {
     }()
 
     private let player: AVPlayer
-    #if !os(visionOS)
-    @Box private var playbackSpeed: Float
-    #endif
     
-    private lazy var muteButton: MuteButton = {
-        let button = MuteButton()
-        button.addTarget(self, action: #selector(muteButtonPressed), for: .touchUpInside)
-        button.setMuted(false, animated: false)
-        return button
-    }()
+    private lazy var muteButton = MuteButton().configure {
+        $0.addTarget(self, action: #selector(muteButtonPressed), for: .touchUpInside)
+        $0.setMuted(false, animated: false)
+    }
     
-    private let timestampLabel: UILabel = {
-        let label = UILabel()
-        label.text = "0:00"
-        label.font = UIFontMetrics(forTextStyle: .caption1).scaledFont(for: .monospacedDigitSystemFont(ofSize: 13, weight: .regular))
-        return label
-    }()
+    private let timestampLabel = UILabel().configure {
+        $0.text = "0:00"
+        $0.font = UIFontMetrics(forTextStyle: .caption1).scaledFont(for: .monospacedDigitSystemFont(ofSize: 13, weight: .regular))
+    }
     
-    private lazy var scrubbingControl: VideoScrubbingControl = {
-        let control = VideoScrubbingControl()
-        control.heightAnchor.constraint(equalToConstant: 44).isActive = true
-        control.addTarget(self, action: #selector(scrubbingStarted), for: .editingDidBegin)
-        control.addTarget(self, action: #selector(scrubbingChanged), for: .editingChanged)
-        control.addTarget(self, action: #selector(scrubbingEnded), for: .editingDidEnd)
-        return control
-    }()
+    private lazy var scrubbingControl = VideoScrubbingControl().configure {
+        $0.heightAnchor.constraint(equalToConstant: 44).isActive = true
+        $0.addTarget(self, action: #selector(scrubbingStarted), for: .editingDidBegin)
+        $0.addTarget(self, action: #selector(scrubbingChanged), for: .editingChanged)
+        $0.addTarget(self, action: #selector(scrubbingEnded), for: .editingDidEnd)
+    }
     
-    private let timeRemainingLabel: UILabel = {
-        let label = UILabel()
-        label.text = "-0:00"
-        label.font = UIFontMetrics(forTextStyle: .caption1).scaledFont(for: .monospacedDigitSystemFont(ofSize: 13, weight: .regular))
-        return label
-    }()
+    private let timeRemainingLabel = UILabel().configure {
+        $0.text = "-0:00"
+        $0.font = UIFontMetrics(forTextStyle: .caption1).scaledFont(for: .monospacedDigitSystemFont(ofSize: 13, weight: .regular))
+    }
     
     private lazy var optionsButton = MenuButton { [unowned self] in
         let imageName: String
-        #if os(visionOS)
-        let playbackSpeed = player.defaultRate
-        #else
-        let playbackSpeed = self.playbackSpeed
-        #endif
         if #available(iOS 17.0, *) {
-            switch playbackSpeed {
+            switch player.defaultRate {
             case 0.5:
                 imageName = "gauge.with.dots.needle.0percent"
             case 1:
@@ -85,12 +60,8 @@ class VideoControlsViewController: UIViewController {
             imageName = "speedometer"
         }
         let speedMenu = UIMenu(title: "Playback Speed", image: UIImage(systemName: imageName), children: PlaybackSpeed.allCases.map { speed in
-            UIAction(title: speed.displayName, state: playbackSpeed == speed.rate ? .on : .off) { [unowned self] _ in
-                #if os(visionOS)
+            UIAction(title: speed.displayName, state: self.player.defaultRate == speed.rate ? .on : .off) { [unowned self] _ in
                 self.player.defaultRate = speed.rate
-                #else
-                self.playbackSpeed = speed.rate
-                #endif
                 if self.player.rate > 0 {
                     self.player.rate = speed.rate
                 }
@@ -99,19 +70,17 @@ class VideoControlsViewController: UIViewController {
         return UIMenu(children: [speedMenu])
     }
     
-    private lazy var hStack: UIStackView = {
-        let stack = UIStackView(arrangedSubviews: [
-            muteButton,
-            timestampLabel,
-            scrubbingControl,
-            timeRemainingLabel,
-            optionsButton,
-        ])
-        stack.axis = .horizontal
-        stack.spacing = 8
-        stack.alignment = .center
-        return stack
-    }()
+    private lazy var hStack = UIStackView(arrangedSubviews: [
+        muteButton,
+        timestampLabel,
+        scrubbingControl,
+        timeRemainingLabel,
+        optionsButton,
+    ]).configure {
+        $0.axis = .horizontal
+        $0.spacing = 8
+        $0.alignment = .center
+    }
 
     private var timestampObserverToken: Any?
     private var scrubberObserverToken: Any?
@@ -120,20 +89,11 @@ class VideoControlsViewController: UIViewController {
     private var scrubbingTargetTime: CMTime?
     private var isSeeking = false
     
-    #if os(visionOS)
     init(player: AVPlayer) {
         self.player = player
         
         super.init(nibName: nil, bundle: nil)
     }
-    #else
-    init(player: AVPlayer, playbackSpeed: Box<Float>) {
-        self.player = player
-        self._playbackSpeed = playbackSpeed
-        
-        super.init(nibName: nil, bundle: nil)
-    }
-    #endif
     
     required init?(coder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
@@ -217,11 +177,7 @@ class VideoControlsViewController: UIViewController {
     @objc private func scrubbingEnded() {
         scrubbingChanged()
         if wasPlayingWhenScrubbingStarted {
-            #if os(visionOS)
             player.play()
-            #else
-            player.rate = playbackSpeed
-            #endif
         }
     }
     

Tusker/Screens/Gallery/VideoGalleryContentViewController.swift

@@ -1,58 +1,68 @@
 //
 //  VideoGalleryContentViewController.swift
-//  GalleryVC
+//  Tusker
 //
 //  Created by Shadowfacts on 3/19/24.
 //  Copyright © 2024 Shadowfacts. All rights reserved.
 //
 
 import UIKit
+import GalleryVC
 import AVFoundation
 import CoreImage
 
-open class VideoGalleryContentViewController: UIViewController, GalleryContentViewController {
-    public let url: URL
-    public let caption: String?
-    public private(set) var item: AVPlayerItem
-    public let player: AVPlayer
+class VideoGalleryContentViewController: UIViewController, GalleryContentViewController {
+    private let url: URL
+    let caption: String?
+    private var item: AVPlayerItem
+    let player: AVPlayer
     
-    #if !os(visionOS)
-    @available(iOS, obsoleted: 16.0, message: "Use AVPlayer.defaultRate")
-    @Box private var playbackSpeed: Float = 1
-    #endif
+    private var isGrayscale: Bool
     
     private var presentationSizeObservation: NSKeyValueObservation?
     private var statusObservation: NSKeyValueObservation?
     private var rateObservation: NSKeyValueObservation?
+    private var isFirstAppearance = true
     private var hideControlsWorkItem: DispatchWorkItem?
-    private var isShowingError = false
+    private var audioSessionToken: AudioSessionCoordinator.Token?
     
-    public init(url: URL, caption: String?) {
+    init(url: URL, caption: String?) {
         self.url = url
         self.caption = caption
         
+        self.isGrayscale = Preferences.shared.grayscaleImages
+        
         let asset = AVAsset(url: url)
-        self.item = Self.createItem(asset: asset)
+        self.item = VideoGalleryContentViewController.createItem(asset: asset)
         self.player = AVPlayer(playerItem: item)
         
         super.init(nibName: nil, bundle: nil)
     }
     
-    public required init?(coder: NSCoder) {
+    required init?(coder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
     }
     
-    open class func createItem(asset: AVAsset) -> AVPlayerItem {
-        return AVPlayerItem(asset: asset)
+    private static func createItem(asset: AVAsset) -> AVPlayerItem {
+        let item = AVPlayerItem(asset: asset)
+        if Preferences.shared.grayscaleImages {
+            #if os(visionOS)
+            #warning("Use async AVVideoComposition CIFilter initializer")
+            #else
+            let filter = CIFilter(name: "CIColorMonochrome")!
+            filter.setValue(CIColor(red: 0.85, green: 0.85, blue: 0.85), forKey: "inputColor")
+            filter.setValue(1.0, forKey: "inputIntensity")
+
+            item.videoComposition = AVVideoComposition(asset: asset, applyingCIFiltersWithHandler: { request in
+                filter.setValue(request.sourceImage, forKey: "inputImage")
+                request.finish(with: filter.outputImage!, context: nil)
+            })
+            #endif
+        }
+        return item
     }
     
-    public func replaceCurrentItem(with item: AVPlayerItem) {
-        self.item = item
-        player.replaceCurrentItem(with: item)
-        updateItemObservations()
-    }
-    
-    public override func viewDidLoad() {
+    override func viewDidLoad() {
         super.viewDidLoad()
         
         container?.setGalleryContentLoading(true)
@@ -77,17 +87,19 @@ open class VideoGalleryContentViewController: UIViewController, GalleryContentVi
                 scheduleControlsHide()
             }
         })
+        
+        NotificationCenter.default.addObserver(self, selector: #selector(preferencesChanged), name: .preferencesChanged, object: nil)
     }
     
     private func updateItemObservations() {
         presentationSizeObservation = item.observe(\.presentationSize, changeHandler: { [unowned self] item, _ in
-            MainActor.assumeIsolated {
+            MainActor.runUnsafely {
                 self.preferredContentSize = item.presentationSize
                 self.container?.galleryContentChanged()
             }
         })
         statusObservation = item.observe(\.status, changeHandler: { [unowned self] item, _ in
-            MainActor.assumeIsolated {
+            MainActor.runUnsafely {
                 if item.status == .readyToPlay {
                     self.container?.setGalleryContentLoading(false)
                     self.statusObservation = nil
@@ -96,22 +108,19 @@ open class VideoGalleryContentViewController: UIViewController, GalleryContentVi
                     self.container?.setGalleryContentLoading(false)
                     self.showErrorView(error)
                     self.statusObservation = nil
-                    self.overlayVC.setVisible(false)
                 }
             }
         })
     }
     
     private func showErrorView(_ error: any Error) {
-        isShowingError = true
-        
         let image = UIImageView(image: UIImage(systemName: "exclamationmark.triangle.fill")!)
         image.tintColor = .secondaryLabel
         image.contentMode = .scaleAspectFit
         
         let label = UILabel()
         label.text = "Error Loading"
-        label.font = UIFont(descriptor: .preferredFontDescriptor(withTextStyle: .title1).withSymbolicTraits(.traitBold)!, size: 0)
+        label.font = .preferredFont(forTextStyle: .title1).withTraits(.traitBold)!
         label.textColor = .secondaryLabel
         label.adjustsFontForContentSizeCategory = true
         
@@ -139,9 +148,22 @@ open class VideoGalleryContentViewController: UIViewController, GalleryContentVi
         ])
     }
     
+    @objc private func preferencesChanged() {
+        if isGrayscale != Preferences.shared.grayscaleImages {
+            let isPlaying = player.rate > 0
+            isGrayscale = Preferences.shared.grayscaleImages
+            item = VideoGalleryContentViewController.createItem(asset: item.asset)
+            player.replaceCurrentItem(with: item)
+            updateItemObservations()
+            if isPlaying {
+                player.play()
+            }
+        }
+    }
+    
     private func scheduleControlsHide() {
         hideControlsWorkItem = DispatchWorkItem { [weak self] in
-            MainActor.assumeIsolated {
+            MainActor.runUnsafely {
                 guard let self,
                       let container = self.container,
                       container.galleryControlsVisible else {
@@ -155,40 +177,25 @@ open class VideoGalleryContentViewController: UIViewController, GalleryContentVi
     
     // MARK: GalleryContentViewController
     
-    public weak var container: (any GalleryVC.GalleryContentViewControllerContainer)?
+    weak var container: (any GalleryVC.GalleryContentViewControllerContainer)?
     
-    public var contentSize: CGSize {
+    var contentSize: CGSize {
         item.presentationSize
     }
     
-    open var activityItemsForSharing: [Any] {
-//        [VideoActivityItemSource(asset: item.asset, url: url)]
-        []
+    var activityItemsForSharing: [Any] {
+        [VideoActivityItemSource(asset: item.asset, url: url)]
     }
     
-    public var presentationAnimation: GalleryContentPresentationAnimation {
-        isShowingError ? .fade : .fromSourceViewWithoutSnapshot
-    }
-    
-    #if os(visionOS)
     private lazy var overlayVC = VideoOverlayViewController(player: player)
-    #else
-    private lazy var overlayVC = VideoOverlayViewController(player: player, playbackSpeed: _playbackSpeed)
-    #endif
-    public var contentOverlayAccessoryViewController: UIViewController? {
+    var contentOverlayAccessoryViewController: UIViewController? {
         overlayVC
     }
     
-    #if os(visionOS)
-    public private(set) lazy var bottomControlsAccessoryViewController: UIViewController? = VideoControlsViewController(player: player)
-    #else
-    public private(set) lazy var bottomControlsAccessoryViewController: UIViewController? = VideoControlsViewController(player: player, playbackSpeed: _playbackSpeed)
-    #endif
+    private(set) lazy var bottomControlsAccessoryViewController: UIViewController? = VideoControlsViewController(player: player)
     
-    public func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool) {
-        if !isShowingError {
-            overlayVC.setVisible(visible)
-        }
+    func setControlsVisible(_ visible: Bool, animated: Bool, dueToUserInteraction: Bool) {
+        overlayVC.setVisible(visible)
         
         if !visible {
             hideControlsWorkItem?.cancel()
@@ -198,11 +205,25 @@ open class VideoGalleryContentViewController: UIViewController, GalleryContentVi
         }
     }
     
-    open func galleryContentDidAppear() {
+    func galleryContentDidAppear() {
+        let wasFirstAppearance = isFirstAppearance
+        isFirstAppearance = false
+        
+        audioSessionToken = AudioSessionCoordinator.shared.beginPlayback(mode: .video) {
+            if wasFirstAppearance {
+                DispatchQueue.main.async {
+                    self.player.play()
+                }
+            }
+        }
     }
     
-    open func galleryContentWillDisappear() {
+    func galleryContentWillDisappear() {
         player.pause()
+        
+        if let audioSessionToken {
+            AudioSessionCoordinator.shared.endPlayback(token: audioSessionToken)
+        }
     }
     
 }
@@ -231,9 +252,9 @@ private class PlayerView: UIView {
         playerLayer.player = player
         playerLayer.videoGravity = .resizeAspect
         
-        presentationSizeObservation = item.observe(\.presentationSize, changeHandler: { [weak self] _, _ in
-            MainActor.assumeIsolated {
-                self?.invalidateIntrinsicContentSize()
+        presentationSizeObservation = item.observe(\.presentationSize, changeHandler: { [unowned self] _, _ in
+            MainActor.runUnsafely {
+                self.invalidateIntrinsicContentSize()
             }
         })
     }

Tusker/Screens/Gallery/VideoOverlayViewController.swift

@@ -1,6 +1,6 @@
 //
 //  VideoOverlayViewController.swift
-//  GalleryVC
+//  Tusker
 //
 //  Created by Shadowfacts on 3/26/24.
 //  Copyright © 2024 Shadowfacts. All rights reserved.
@@ -15,9 +15,6 @@ class VideoOverlayViewController: UIViewController {
     private static let pauseImage = UIImage(systemName: "pause.fill")!
 
     private let player: AVPlayer
-    #if !os(visionOS)
-    @Box private var playbackSpeed: Float
-    #endif
     
     private var dimmingView: UIView!
     private var controlsStack: UIStackView!
@@ -26,18 +23,10 @@ class VideoOverlayViewController: UIViewController {
 
     private var rateObservation: NSKeyValueObservation?
     
-    #if os(visionOS)
     init(player: AVPlayer) {
         self.player = player
         super.init(nibName: nil, bundle: nil)
     }
-    #else
-    init(player: AVPlayer, playbackSpeed: Box<Float>) {
-        self.player = player
-        self._playbackSpeed = playbackSpeed
-        super.init(nibName: nil, bundle: nil)
-    }
-    #endif
 
     required init?(coder: NSCoder) {
         fatalError("init(coder:) has not been implemented")
@@ -90,7 +79,7 @@ class VideoOverlayViewController: UIViewController {
         ])
         
         rateObservation = player.observe(\.rate, changeHandler: { player, _ in
-            MainActor.assumeIsolated {
+            MainActor.runUnsafely {
                 playPauseButton.image = player.rate > 0 ? VideoOverlayViewController.pauseImage : VideoOverlayViewController.playImage
             }
         })
@@ -109,11 +98,7 @@ class VideoOverlayViewController: UIViewController {
             if player.currentTime() >= player.currentItem!.duration {
                 player.seek(to: .zero)
             }
-            #if os(visionOS)
             player.play()
-            #else
-            player.rate = playbackSpeed
-            #endif
         }
     }
     

Tusker/Screens/Lists/EditListAccountsViewController.swift

@@ -100,28 +100,13 @@ class EditListAccountsViewController: UIViewController, CollectionViewController
         
         navigationItem.searchController = searchController
         navigationItem.hidesSearchBarWhenScrolling = false
-        if #available(iOS 16.0, *) {
-            navigationItem.preferredSearchBarPlacement = .stacked
-            
-            navigationItem.renameDelegate = self
-            navigationItem.titleMenuProvider = { [unowned self] suggested in
-                var children = suggested
-                children.append(contentsOf: self.listSettingsMenuElements())
-                return UIMenu(children: children)
-            }
-        } else {
-            navigationItem.leftBarButtonItem = UIBarButtonItem(title: "Edit", menu: UIMenu(children: [
-                // uncached so that menu always reflects the current state of the list
-                UIDeferredMenuElement.uncached({ [unowned self] elementHandler in
-                    var elements = self.listSettingsMenuElements()
-                    elements.insert(UIAction(title: "Rename…", image: UIImage(systemName: "pencil"), handler: { [unowned self] _ in
-                        RenameListService(list: self.list, mastodonController: self.mastodonController, present: {
-                            self.present($0, animated: true)
-                        }).run()
-                    }), at: 0)
-                    elementHandler(elements)
-                })
-            ]))
+        navigationItem.preferredSearchBarPlacement = .stacked
+        
+        navigationItem.renameDelegate = self
+        navigationItem.titleMenuProvider = { [unowned self] suggested in
+            var children = suggested
+            children.append(contentsOf: self.listSettingsMenuElements())
+            return UIMenu(children: children)
         }
     }
     

Tusker/Screens/Main/BaseMainTabBarViewController.swift

@@ -151,22 +151,6 @@ class BaseMainTabBarViewController: UITabBarController, FastAccountSwitcherViewC
         return false
         #endif // !os(visionOS)
     }
-    
-    // MARK: Keyboard shortcuts
-    
-    override func target(forAction action: Selector, withSender sender: Any?) -> Any? {
-        // This is a silly workaround for when the sidebar is focused (and therefore first responder), which,
-        // unfortunately, is almost always. Because the content view controller then isn't in the responder chain,
-        // we manually delegate to the top view controller if possible.
-        if action == #selector(RefreshableViewController.refresh),
-           let selected = selectedViewController as? NavigationControllerProtocol,
-           let top = selected.topViewController as? RefreshableViewController {
-            return top
-        } else {
-            return super.target(forAction: action, withSender: sender)
-        }
-    }
-
 }
 
 extension BaseMainTabBarViewController: TuskerNavigationDelegate {

Tusker/Screens/Main/MainSplitViewController.swift

@@ -219,19 +219,6 @@ class MainSplitViewController: UISplitViewController {
     @objc func handleComposeKeyCommand() {
         compose(editing: nil)
     }
-    
-    override func target(forAction action: Selector, withSender sender: Any?) -> Any? {
-        // This is a silly workaround for when the sidebar is focused (and therefore first responder), which,
-        // unfortunately, is almost always. Because the content view controller then isn't in the responder chain,
-        // we manually delegate to the top view controller if possible.
-        if action == #selector(RefreshableViewController.refresh),
-           traitCollection.horizontalSizeClass == .regular,
-           let top = secondaryNavController.topViewController as? RefreshableViewController {
-            return top
-        } else {
-            return super.target(forAction: action, withSender: sender)
-        }
-    }
 
 }
 

Tusker/Screens/Main/NewMainTabBarViewController.swift

@@ -33,13 +33,6 @@ final class NewMainTabBarViewController: BaseMainTabBarViewController {
     private var isCompact: Bool?
     @Box fileprivate var myProfileCell: UIView?
     private var sidebarTapRecognizer: UITapGestureRecognizer?
-    
-    private lazy var fastAccountSwitcherIndicator: UIView = {
-        let indicator = FastAccountSwitcherIndicatorView()
-        // need to explicitly set the frame to get it vertically centered
-        indicator.frame = CGRect(origin: .zero, size: indicator.intrinsicContentSize)
-        return indicator
-    }()
 
     override func viewDidLoad() {
         super.viewDidLoad()
@@ -520,6 +513,13 @@ extension NewMainTabBarViewController: UITabBarControllerDelegate {
     }
 }
 
+private var fastAccountSwitcherIndicator: UIView = {
+    let indicator = FastAccountSwitcherIndicatorView()
+    // need to explicitly set the frame to get it vertically centered
+    indicator.frame = CGRect(origin: .zero, size: indicator.intrinsicContentSize)
+    return indicator
+}()
+
 @available(iOS 18.0, *)
 extension NewMainTabBarViewController: UITabBarController.Sidebar.Delegate {
     func tabBarController(_ tabBarController: UITabBarController, sidebarVisibilityWillChange sidebar: UITabBarController.Sidebar, animator: any UITabBarController.Sidebar.Animating) {

Tusker/Screens/Mute/MuteAccountView.swift

@@ -41,15 +41,8 @@ struct MuteAccountView: View {
     @State private var error: Error?
     
     var body: some View {
-        if #available(iOS 16.0, *) {
-            NavigationStack {
-                navigationViewContent
-            }
-        } else {
-            NavigationView {
-                navigationViewContent
-            }
-            .navigationViewStyle(.stack)
+        NavigationStack {
+            navigationViewContent
         }
     }
     

Tusker/Screens/Notifications/FollowRequestNotificationViewController.swift

@@ -101,14 +101,8 @@ extension FollowRequestNotificationViewController: UICollectionViewDelegate {
                 UIAction(title: "Accept", image: UIImage(systemName: "checkmark.circle"), handler: { _ in cell.acceptButtonPressed() }),
                 UIAction(title: "Reject", image: UIImage(systemName: "xmark.circle"), handler: { _ in cell.rejectButtonPressed() }),
             ]
-            let acceptRejectMenu: UIMenu
-            if #available(iOS 16.0, *) {
-                acceptRejectMenu = UIMenu(options: .displayInline, preferredElementSize: .medium, children: acceptRejectChildren)
-            } else {
-                acceptRejectMenu = UIMenu(options: .displayInline, children: acceptRejectChildren)
-            }
             return UIMenu(children: [
-                acceptRejectMenu,
+                UIMenu(options: .displayInline, preferredElementSize: .medium, children: acceptRejectChildren),
                 UIMenu(options: .displayInline, children: self.actionsForProfile(accountID: accountID, source: .view(cell))),
             ])
         }

Tusker/Screens/Notifications/NotificationLoadingViewController.swift

@@ -48,9 +48,7 @@ class NotificationLoadingViewController: UIViewController {
             do {
                 let (notification, _) = try await mastodonController.run(request)
                 await withCheckedContinuation { continuation in
-                    let container = mastodonController.persistentContainer
-                    let context = container.viewContext
-                    container.addAll(notifications: [notification], in: context) {
+                    mastodonController.persistentContainer.addAll(notifications: [notification]) {
                         continuation.resume()
                     }
                 }

Tusker/Screens/Notifications/NotificationsCollectionViewController.swift

@@ -700,14 +700,8 @@ extension NotificationsCollectionViewController: UICollectionViewDelegate {
                     UIAction(title: "Accept", image: UIImage(systemName: "checkmark.circle"), handler: { _ in cell.acceptButtonPressed() }),
                     UIAction(title: "Reject", image: UIImage(systemName: "xmark.circle"), handler: { _ in cell.rejectButtonPressed() }),
                 ]
-                let acceptRejectMenu: UIMenu
-                if #available(iOS 16.0, *) {
-                    acceptRejectMenu = UIMenu(options: .displayInline, preferredElementSize: .medium, children: acceptRejectChildren)
-                } else {
-                    acceptRejectMenu = UIMenu(options: .displayInline, children: acceptRejectChildren)
-                }
                 return UIMenu(children: [
-                    acceptRejectMenu,
+                    UIMenu(options: .displayInline, preferredElementSize: .medium, children: acceptRejectChildren),
                     UIMenu(options: .displayInline, children: self.actionsForProfile(accountID: accountID, source: .view(cell))),
                 ])
             }

Tusker/Screens/Notifications/NotificationsPageViewController.swift

@@ -180,9 +180,3 @@ extension NotificationsPageViewController: StateRestorableViewController {
         return currentPage.userActivity(accountID: mastodonController.accountInfo!.id)
     }
 }
-
-extension NotificationsPageViewController: RefreshableViewController {
-    func refresh() {
-        (currentViewController as? RefreshableViewController)?.refresh()
-    }
-}

Tusker/Screens/Onboarding/InstanceSelectorTableViewController.swift

@@ -75,14 +75,13 @@ class InstanceSelectorTableViewController: UITableViewController {
         
         dataSource = UITableViewDiffableDataSource(tableView: tableView, cellProvider: { (tableView, indexPath, item) -> UITableViewCell? in
             switch item {
-            case let .selected(_, info):
+            case let .selected(_, instance):
                 let cell = tableView.dequeueReusableCell(withIdentifier: instanceCell, for: indexPath) as! InstanceTableViewCell
-                cell.updateUI(info: info)
+                cell.updateUI(instance: instance)
                 return cell
             case let .recommended(instance):
                 let cell = tableView.dequeueReusableCell(withIdentifier: instanceCell, for: indexPath) as! InstanceTableViewCell
-                let info = Info(host: instance.domain, description: instance.description, thumbnail: instance.proxiedThumbnailURL, adult: instance.category == "adult")
-                cell.updateUI(info: info)
+                cell.updateUI(instance: instance)
                 return cell
             }
         })
@@ -97,9 +96,7 @@ class InstanceSelectorTableViewController: UITableViewController {
         searchController.searchBar.placeholder = "Search or enter a URL"
         navigationItem.searchController = searchController
         navigationItem.hidesSearchBarWhenScrolling = false
-        if #available(iOS 16.0, *) {
-            navigationItem.preferredSearchBarPlacement = .stacked
-        }
+        navigationItem.preferredSearchBarPlacement = .stacked
         definesPresentationContext = true
         
         urlHandler = urlCheckerSubject
@@ -165,20 +162,22 @@ class InstanceSelectorTableViewController: UITableViewController {
             return
         }
 
-        checkSpecificInstance(url: url) { (info) in
+        let client = Client(baseURL: url, session: .appDefault)
+        let request = Client.getInstanceV1()
+        client.run(request) { (response) in
             var snapshot = self.dataSource.snapshot()
             if snapshot.indexOfSection(.selected) != nil {
                 snapshot.deleteSections([.selected])
             }
 
-            if let info {
+            if case let .success(instance, _) = response {
                 if snapshot.indexOfSection(.recommendedInstances) != nil {
                     snapshot.insertSections([.selected], beforeSection: .recommendedInstances)
                 } else {
                     snapshot.appendSections([.selected])
                 }
                 
-                snapshot.appendItems([.selected(url, info)], toSection: .selected)
+                snapshot.appendItems([.selected(url, instance)], toSection: .selected)
                 
                 DispatchQueue.main.async {
                     self.dataSource.apply(snapshot) {
@@ -193,29 +192,6 @@ class InstanceSelectorTableViewController: UITableViewController {
         }
     }
     
-    private func checkSpecificInstance(url: URL, completionHandler: @escaping (Info?) -> Void) {
-        let client = Client(baseURL: url, session: .appDefault)
-        let request = Client.getInstanceV1()
-        client.run(request) { response in
-            switch response {
-            case .success(let instance, _):
-                let host = url.host ?? URLComponents(string: instance.uri)?.host ?? instance.uri
-                let info = Info(host: host, description: instance.shortDescription ?? instance.description, thumbnail: instance.thumbnail, adult: false)
-                completionHandler(info)
-            case .failure(_):
-                Task {
-                    do {
-                        let nodeInfo = try await client.nodeInfo()
-                        let info = Info(host: url.host!, description: nodeInfo.metadata.nodeDescription, thumbnail: nil, adult: false)
-                        completionHandler(info)
-                    } catch {
-                        completionHandler(nil)
-                    }
-                }
-            }
-        }
-    }
-    
     private func loadRecommendedInstances() {
         InstanceSelector.getInstances(category: nil) { (response) in
             DispatchQueue.main.async {
@@ -334,13 +310,13 @@ extension InstanceSelectorTableViewController {
         case recommendedInstances
     }
     enum Item: Equatable, Hashable, Sendable {
-        case selected(URL, Info)
+        case selected(URL, InstanceV1)
         case recommended(InstanceSelector.Instance)
         
         static func ==(lhs: Item, rhs: Item) -> Bool {
             switch (lhs, rhs) {
-            case let (.selected(urlA, _), .selected(urlB, _)):
-                return urlA == urlB
+            case let (.selected(urlA, instanceA), .selected(urlB, instanceB)):
+                return urlA == urlB && instanceA.uri == instanceB.uri
             case let (.recommended(a), .recommended(b)):
                 return a.domain == b.domain
             default:
@@ -350,21 +326,16 @@ extension InstanceSelectorTableViewController {
         
         func hash(into hasher: inout Hasher) {
             switch self {
-            case let .selected(url, _):
+            case let .selected(url, instance):
                 hasher.combine(0)
                 hasher.combine(url)
+                hasher.combine(instance.uri)
             case let .recommended(instance):
                 hasher.combine(1)
                 hasher.combine(instance.domain)
             }
         }
     }
-    struct Info: Hashable {
-        let host: String
-        let description: String
-        let thumbnail: URL?
-        let adult: Bool
-    }
 }
 
 extension InstanceSelectorTableViewController: UISearchResultsUpdating {