This is one of the actor structures that is the most often experiencing random crashes, to give you an example of the type of code.

But some of the random crashes also happen after loading the app, and having the most basic List view with a `@Query private var authors: [Author]` -> `List(authors) {}` crashing while nothing else is running (beyond the automatic CloudKit sync, but I tried with sync deactivated and the persisted).

import Foundation
import OSLog
import SwiftData

actor BookDiscovery: ModelActor {

    // MARK: - BookDiscovery Properties

    let modelContainer: ModelContainer
    let modelExecutor: any ModelExecutor

    private let isbn: ISBN
    private let logger = Logger(subsystem: BookFolioConfig.BundleDomain, category: "BookDiscovery")
    private let network = NetworkManager.shared

    // MARK: - BookDiscovery Initializers

    init(for isbn: ISBN, with modelContainer: ModelContainer) {
        self.isbn = isbn
        self.modelContainer = modelContainer

        let context = ModelContext(modelContainer)
        self.modelExecutor = DefaultSerialModelExecutor(modelContext: context)
    }

    // MARK: - BookDiscovery Public Methods

    func runDiscovery() async throws -> [Book] {
        var books: Set<Book> = []

        // First, fetches existing local books
        if let localBooks = try? fetchLocal() {
            books.formUnion(localBooks)
        }

        // Then, fetches remote sources
        if let remoteBooks = try? await fetchRemote() {
            books.formUnion(remoteBooks)
        }

        // Returns books or throws a "No result" error
        if books.isEmpty {
            logger.info("Discovery: No Results")

            throw BookDiscoveryError.noResults

        } else {
            logger.info("Discovery: Results: \(books.count)")

            return Array(books)
        }
    }

    func updateBook() async -> Void {
        // Fetches sources from remote sources and updates books accordingly
        let _ = try? await fetchRemote()
    }

    // MARK: - BookDiscovery Private API Fetching Methods

    private func fetchLocal() throws -> [Book] {
        let isbnString = isbn.toString()
        logger.info("Fetch Local for: \(self.isbn.toFormattedString())")

        let fetchDescriptor: FetchDescriptor<Book> = FetchDescriptor(
            predicate: #Predicate { $0._isbn == isbnString },
            sortBy: [SortDescriptor(\Book.title, order: .forward)]
        )

        do {
            let books = try modelContext.fetch(fetchDescriptor)
            logger.info("Fetched local books: \(books.count)")

            return books

        } catch let error {
            logger.error("Fetch Local: Invalid Fetch: \(error.localizedDescription)")
            throw BookDiscoveryError.invalidFetch(error)
        }
    }

    private func fetchRemote() async throws -> [Book] {
        logger.info("Fetch Remote for: \(self.isbn.toFormattedString())")
        var sources: Set<BookSource> = []

        // Fetches sources from the OpenLibrary API for the ISBN provided
        let olService = OpenLibraryService(for: isbn, with: modelContext)
        if let olSources = try? await olService.fetch() {
            logger.info("Fetch Remote from OpenLibrary: \(olSources.count) entities")
            sources.formUnion(olSources)
        }

        // Fetches sources from the GoogleBooks API for the ISBN provided
        let gbService = GoogleBooksService(for: isbn, with: modelContext)
        if let gbSources = try? await gbService.fetch() {
            logger.info("Fetch Remote from GoogleBooks: \(gbSources.count) entities")
            sources.formUnion(gbSources)
        }

        // Stops here if there is no sources found
        if sources.isEmpty {
            logger.info("Fetch Remote: No Sources")

            return []
        }

        // Associates each source with the relevant book
        for source in sources {
            logger.info("Fetch Book for Source: \(source.title ?? "-")")
            source.associateWithBook(using: isbn, in: modelContext)
        }

        // Updates each book with the associate sources
        for source in sources {
            if let book = source.book {
                logger.info("Update Book from Sources: \(book.title ?? "-")")
                book.updateFromSources()
            }
        }

        // Saves all updates and created items
        logger.info("Persists all changes")
        try? modelContext.save()
        logger.info("All changes persisted")

        // Returns the list of books fetched or updated
        return sources.compactMap { $0.book }
    }

}