First Pass

Author: bmalumphy

sdks/swift/Sources/DittoChatCore/DittoChat.swift

@@ -128,10 +128,16 @@ public class DittoChat: DittoSwiftChat, ObservableObject {
         self.notificationManager = manager
 
         // Whenever the public rooms list changes, reconcile which rooms are being observed.
+        // Use Task { @MainActor in } rather than .receive(on: DispatchQueue.main) so that
+        // syncRooms — an @MainActor method — is entered through Swift's structured concurrency
+        // executor. In Xcode 26.4 / Swift 6.3, calling @MainActor methods via raw GCD from a
+        // nonisolated Combine sink triggers a runtime actor-isolation crash even when on the
+        // main thread.
         p2pStore.publicRoomsPublisher
-            .receive(on: DispatchQueue.main)
             .sink { [weak manager] rooms in
-                manager?.syncRooms(rooms)
+                Task { @MainActor [weak manager] in
+                    manager?.syncRooms(rooms)
+                }
             }
             .store(in: &cancellables)
 

sdks/swift/Sources/DittoChatCore/PushNotifications/ChatNotificationManager.swift

@@ -5,7 +5,7 @@
 //  Copyright © 2025 DittoLive Incorporated. All rights reserved.
 //
 
-import DittoSwift
+@preconcurrency import DittoSwift
 import Foundation
 import UserNotifications
 
@@ -84,42 +84,45 @@ final class ChatNotificationManager {
     private func startObserving(room: Room) {
         guard let ditto, roomObservers[room.id] == nil else { return }
 
-        // Query the most recent 50 messages; no attachment tokens needed for text preview.
         let query = """
             SELECT * FROM `\(room.messagesId)`
             WHERE roomId == :roomId
             ORDER BY createdOn DESC
             LIMIT 50
             """
 
-        let roomId = room.id
-        let roomName = room.name
-
         do {
-            // deliverOn: .global() — deliver on a background thread so the callback fires
-            // immediately when Ditto's internal sync engine receives data, without needing
-            // the main RunLoop to iterate first. This is critical when the app is backgrounded:
-            // iOS keeps the main RunLoop alive for BLE-mode apps, but delivering directly on a
-            // global queue means callbacks are not queued behind any pending main-thread work.
-            //
-            // Message parsing (compactMap) happens on the background thread; only the actor-
-            // isolated state mutations hop to .main via DispatchQueue.main.async, which is
-            // lightweight and safe while the app has any background execution time.
-            let observer = try ditto.store.registerObserver(
-                query: query,
-                arguments: ["roomId": roomId],
-                deliverOn: .global(qos: .utility)
-            ) { [weak self] result in
-                // Parse off the main thread — no actor-isolated state touched here.
-                let messages = result.items.compactMap { Message(value: $0.value) }
-                // Hop to main for @MainActor state mutations and UNUserNotificationCenter.
-                DispatchQueue.main.async { [weak self] in
-                    self?.handle(messages: messages, roomId: roomId, roomName: roomName)
-                }
-            }
+            // registerObserver is called from a nonisolated helper so that the closure passed
+            // to Ditto is created in a nonisolated context. Swift 6.3 injects
+            // _swift_task_checkIsolatedSwift into the prologue of any closure created inside an
+            // @MainActor method — even if all captures are nonisolated(unsafe) — crashing when
+            // Ditto delivers the callback on utility-qos. Moving closure creation into a
+            // nonisolated method removes that coloring entirely.
+            let observer = try makeObserver(store: ditto.store, query: query,
+                                            roomId: room.id, roomName: room.name)
             roomObservers[room.id] = observer
         } catch {
-            print("ChatNotificationManager: failed to register observer for room \(roomId): \(error)")
+            print("ChatNotificationManager: failed to register observer for room \(room.id): \(error)")
+        }
+    }
+
+    /// Creates and registers a Ditto store observer from a `nonisolated` context.
+    /// Closures defined here carry no `@MainActor` coloring, so Swift 6.3 does not inject
+    /// actor-isolation checks into their prologues.
+    nonisolated private func makeObserver(
+        store: DittoStore,
+        query: String,
+        roomId: String,
+        roomName: String
+    ) throws -> DittoStoreObserver {
+        nonisolated(unsafe) weak var weakSelf: ChatNotificationManager? = self
+        return try store.registerObserver(query: query, arguments: ["roomId": roomId]) { result in
+            let messages = result.items.compactMap { Message(value: $0.value) }
+            DispatchQueue.main.async {
+                MainActor.assumeIsolated {
+                    weakSelf?.handle(messages: messages, roomId: roomId, roomName: roomName)
+                }
+            }
         }
     }
 

sdks/swift/Sources/DittoChatCore/Utilities/Concurrency.swift

@@ -21,13 +21,14 @@ extension Publisher where Output: Sendable {
     ) -> Publishers.FlatMap<Future<T, Error>, Self> {
         flatMap { value in
             Future { promise in
-                let box = SendableBox(promise)
+                let vBox = SendableBox(value)
+                let pBox = SendableBox(promise)
                 Task {
                     do {
-                        let output = try await transform(value)
-                        box.value(.success(output))
+                        let output = try await transform(vBox.value)
+                        pBox.value(.success(output))
                     } catch {
-                        box.value(.failure(error))
+                        pBox.value(.failure(error))
                     }
                 }
             }
@@ -39,10 +40,11 @@ extension Publisher where Output: Sendable {
     ) -> Publishers.FlatMap<Future<T, Never>, Self> {
         flatMap { value in
             Future { promise in
-                let box = SendableBox(promise)
+                let vBox = SendableBox(value)
+                let pBox = SendableBox(promise)
                 Task {
-                    let output = await transform(value)
-                    box.value(.success(output))
+                    let output = await transform(vBox.value)
+                    pBox.value(.success(output))
                 }
             }
         }

sdks/swift/Sources/DittoChatCore/Utilities/Publishers.swift

@@ -47,6 +47,11 @@ extension DittoStore {
 extension DittoStore {
 
     // Send mapped objects as an array
+    //
+    // NOTE: Despite `deliverOn: .main` being the default, the Ditto runtime delivers callbacks on
+    // an internal utility-qos thread in Xcode 26 / Swift 6.3. All callers use the result for
+    // @MainActor-isolated state (DittoService.allPublicRooms, ViewModel @Published properties),
+    // so we force delivery onto DispatchQueue.main here rather than relying on the Ditto parameter.
     func observePublisher<T: DittoDecodable>(query: String, arguments: [String : Any?]? = nil, deliverOn queue: DispatchQueue = .main, mapTo: T.Type) -> AnyPublisher<[T], Error> {
         let subject = PassthroughSubject<[T], Error>()
 
@@ -59,7 +64,7 @@ extension DittoStore {
             subject.send(completion: .failure(error))
         }
 
-        return subject.eraseToAnyPublisher()
+        return subject.receive(on: DispatchQueue.main).eraseToAnyPublisher()
     }
 
     // Send a mapped object as a single value instead of an array
@@ -76,6 +81,6 @@ extension DittoStore {
             subject.send(completion: .failure(error))
         }
 
-        return subject.eraseToAnyPublisher()
+        return subject.receive(on: DispatchQueue.main).eraseToAnyPublisher()
     }
 }