How to avoid deadlock / hang when using SwiftData and @Observable?

Could anyone point me to what I'm doing wrong, please?

Task.detached takes a @Sendable closure, which cannot capture non-Sendable things. However, the closures you are using are capturing [Item], ContentView, and AppState, which are all non-Sendable. If you turn on complete concurrency checking, there will be many warnings in your code.

You should isolate the whole ContentView to MainActor instead of marking its individual methods as @MainActor.

Then, use the .task(id:) modifier to launch tasks instead of Task.detached. If you want to run something on a non-main thread, put it in an asynchronous nonisolated func or a function isolated to another actor.

SwiftData models are not Sendable - so the idea of "one Task.detached creates Items and adds them to a queue, and another Task.detached takes them out of the queue" doesn't work. You should instead work with something Sendable, like a simple struct with all let properties, that contains all you need to create an Item. You should create the Item just before you insert it into the context.

Here is your code after those transformations:

@MainActor
struct ContentView: View {
    private let logger = Logger(subsystem: "TestApp", category: "General")
    @Environment(\.modelContext) private var modelContext
    @Query private var items: [Item]
    @State private var state = AppState()
    
    @State private var testsRunning = false
    
    // when you want to cancel these tasks, just set these to false
    @State private var remoteTask = false
    @State private var syncTask = false

    
    var body: some View {
        VStack {
            Button ("Begin") {
                testsRunning = true
                runTests()
            }.disabled(testsRunning)
            Text("Remote Queue: \(state.queue.count)")
            List (items) {
                Text($0.name)
            }
        }
        .task(id: remoteTask) {
            if remoteTask {
                await startRemoteWork()
            }
        }
        .task(id: syncTask) {
            if syncTask {
                await startSync()
            }
        }
    }
}

extension ContentView {
    func runTests() {
        for item in items {
            modelContext.delete(item)
        }
        state.queue.removeAll()
        
        remoteTask = true
        syncTask = true
    }
    
    func startRemoteWork() async {
        while !Task.isCancelled {
            let newItemName = await fetchItemName()
            state.queue.append(newItemName)
            logger.info("\(Date.now): \(newItemName) added to remote queue")
        }
    }
    
    nonisolated func fetchItemName() async -> String {
        await sleep(duration: .random(in: 0.2...0.5))
        return UUID().uuidString
    }
    
    func syncQueuedItems(with itemsActor: ItemsActor) async {
        let queue = state.queue
        state.queue = []
        await itemsActor.insertItems(withNames: queue)
    }
    
    func startSync() async {
        logger.info("  \(Date.now): Sync Task Started")
        let itemsActor = ItemsActor(modelContainer: modelContext.container)
        while !Task.isCancelled {
            await syncQueuedItems(with: itemsActor)
            logger.info("  \(Date.now): Sync Task sleeping for 3 seconds till next sync")
            await sleep(duration: 3)
        }
    }
}

@ModelActor
actor ItemsActor {
    private let logger = Logger(subsystem: "ItemsActor", category: "General")
    func insertItems(withNames names: [String]) async {
        for name in names {
            let delay = Double.random(in: 0.01...0.05)
            logger.info("    \(Date.now): syncing \(name)")
            modelContext.insert(Item(name: name))
            await sleep(duration: delay)
            logger.info("    \(Date.now): Done")
            if Task.isCancelled {
                break
            }
        }
    }
}

func sleep(duration: Double) async {
    do {
        try await Task.sleep(nanoseconds: UInt64(duration * 1_000_000_000))
    } catch { fatalError("Sleep failed") }
}

• I've made queue in AppState store an array of strings representing item names. This is Sendable, so it can be sent to the model actor for insertion
• fetchItemName is non-isolated, so it will not be running on the main thread when you await it.
• insertItems(withNames:) is isolated to ItemsActor, so it will also not be running on the main thread.
• The logic in syncQueuedItems is slightly different from your code. I simply took everything in the queue and inserted everything. It is also possible to do it your way, but this would involve a lot of hopping between the main actor and ItemsActor.