diff --git a/BookPlayer/AppDelegate.swift b/BookPlayer/AppDelegate.swift
index cb1ccb859..c85700f33 100644
--- a/BookPlayer/AppDelegate.swift
+++ b/BookPlayer/AppDelegate.swift
@@ -523,7 +523,8 @@ extension AppDelegate {
     } else {
       let dataManager = DataManager(coreDataStack: stack)
       let accountService = makeAccountService(dataManager: dataManager)
-      let libraryService = makeLibraryService(dataManager: dataManager)
+      let audioMetadataService = makeAudioMetadataService()
+      let libraryService = makeLibraryService(dataManager: dataManager, audioMetadataService: audioMetadataService)
       let syncService = makeSyncService(accountService: accountService, libraryService: libraryService)
       let playbackService = makePlaybackService(libraryService: libraryService)
       let playerManager = PlayerManager(
@@ -571,9 +572,13 @@ extension AppDelegate {
     return service
   }
 
-  private func makeLibraryService(dataManager: DataManager) -> LibraryService {
+  private func makeAudioMetadataService() -> AudioMetadataService {
+    return AudioMetadataService()
+  }
+
+  private func makeLibraryService(dataManager: DataManager, audioMetadataService: AudioMetadataServiceProtocol) -> LibraryService {
     let service = LibraryService()
-    service.setup(dataManager: dataManager)
+    service.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
     return service
   }
 
diff --git a/BookPlayer/Coordinators/DataInitializerCoordinator.swift b/BookPlayer/Coordinators/DataInitializerCoordinator.swift
index 9d9f1055b..09711e969 100644
--- a/BookPlayer/Coordinators/DataInitializerCoordinator.swift
+++ b/BookPlayer/Coordinators/DataInitializerCoordinator.swift
@@ -179,7 +179,7 @@ class DataInitializerCoordinator: BPLogger {
 
     if shouldRebuildFromFiles {
       let files = getLibraryFiles()
-      coreServices.libraryService.insertItems(from: files)
+      await coreServices.libraryService.insertItems(from: files)
     }
 
     await MainActor.run {
diff --git a/BookPlayer/Library/ItemList/ItemListView+Alerts.swift b/BookPlayer/Library/ItemList/ItemListView+Alerts.swift
index ca0e59bde..989453d04 100644
--- a/BookPlayer/Library/ItemList/ItemListView+Alerts.swift
+++ b/BookPlayer/Library/ItemList/ItemListView+Alerts.swift
@@ -68,6 +68,7 @@ extension ItemListView {
     }
     
     Button("existing_playlist_button") {
+      model.pendingMoveItemIdentifiers = alertParameters.itemIdentifiers
       model.selectedSetItems = Set(alertParameters.itemIdentifiers)
       activeSheet = .foldersSelection
     }
diff --git a/BookPlayer/Library/ItemList/ItemListViewModel.swift b/BookPlayer/Library/ItemList/ItemListViewModel.swift
index 9e5bfe500..cd9d81e43 100644
--- a/BookPlayer/Library/ItemList/ItemListViewModel.swift
+++ b/BookPlayer/Library/ItemList/ItemListViewModel.swift
@@ -77,6 +77,9 @@ final class ItemListViewModel: ObservableObject {
     }
   }
   @Published var selectedItems = [SimpleLibraryItem]()
+  /// Stores item identifiers from import operations to avoid race condition
+  /// where items may not be loaded in the UI yet when moving to a folder
+  var pendingMoveItemIdentifiers: [String]?
 
   /// Search
   @Published var scope: ItemListSearchScope = .all
@@ -410,7 +413,15 @@ extension ItemListViewModel {
   }
 
   func handleMoveIntoFolder(_ folder: SimpleLibraryItem) {
-    let fetchedItems = selectedItems.compactMap({ $0.relativePath })
+    // Use pendingMoveItemIdentifiers if available (from import operations),
+    // otherwise fall back to selectedItems (from manual selection)
+    let fetchedItems: [String]
+    if let pendingItems = pendingMoveItemIdentifiers {
+      fetchedItems = pendingItems
+      pendingMoveItemIdentifiers = nil
+    } else {
+      fetchedItems = selectedItems.compactMap({ $0.relativePath })
+    }
 
     do {
       try libraryService.moveItems(fetchedItems, inside: folder.relativePath)
diff --git a/BookPlayer/Library/ItemList/LibraryRootView.swift b/BookPlayer/Library/ItemList/LibraryRootView.swift
index 97f92d189..a3b4720f8 100644
--- a/BookPlayer/Library/ItemList/LibraryRootView.swift
+++ b/BookPlayer/Library/ItemList/LibraryRootView.swift
@@ -181,7 +181,7 @@ struct LibraryRootView: View {
     guard !files.isEmpty else { return }
 
     Task { @MainActor in
-      let processedItems = libraryService.insertItems(from: files)
+      let processedItems = await libraryService.insertItems(from: files)
       var itemIdentifiers = processedItems.map({ $0.relativePath })
       do {
         await syncService.scheduleUpload(items: processedItems)
diff --git a/BookPlayer/Library/ItemList/Views/BookView.swift b/BookPlayer/Library/ItemList/Views/BookView.swift
index 949b81a11..397b02a3d 100644
--- a/BookPlayer/Library/ItemList/Views/BookView.swift
+++ b/BookPlayer/Library/ItemList/Views/BookView.swift
@@ -70,8 +70,9 @@ struct BookView: View {
   @Previewable var syncService: SyncService = {
     let syncService = SyncService()
     let dataManager = DataManager(coreDataStack: CoreDataStack(testPath: ""))
+    let audioMetadataService = AudioMetadataService()
     let libraryService = LibraryService()
-    libraryService.setup(dataManager: dataManager)
+    libraryService.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
     syncService.setup(
       isActive: true,
       libraryService: libraryService
diff --git a/BookPlayer/Profile/Profile/ProfileListenedSectionView.swift b/BookPlayer/Profile/Profile/ProfileListenedSectionView.swift
index 7cdcfb766..198a698e5 100644
--- a/BookPlayer/Profile/Profile/ProfileListenedSectionView.swift
+++ b/BookPlayer/Profile/Profile/ProfileListenedSectionView.swift
@@ -68,7 +68,8 @@ struct ProfileListenedSectionView: View {
   @Previewable var libraryService: LibraryService = {
     let libraryService = LibraryService()
     let dataManager = DataManager(coreDataStack: CoreDataStack(testPath: ""))
-    libraryService.setup(dataManager: dataManager)
+    let audioMetadataService = AudioMetadataService()
+    libraryService.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
 
     return libraryService
   }()
diff --git a/BookPlayer/Profile/Profile/ProfileSyncTasksSectionView.swift b/BookPlayer/Profile/Profile/ProfileSyncTasksSectionView.swift
index cf33b57a3..9bcd8336f 100644
--- a/BookPlayer/Profile/Profile/ProfileSyncTasksSectionView.swift
+++ b/BookPlayer/Profile/Profile/ProfileSyncTasksSectionView.swift
@@ -91,8 +91,9 @@ struct ProfileSyncTasksSectionView: View {
 #Preview {
   @Previewable var syncService: SyncService = {
     let dataManager = DataManager(coreDataStack: CoreDataStack(testPath: ""))
+    let audioMetadataService = AudioMetadataService()
     let libraryService = LibraryService()
-    libraryService.setup(dataManager: dataManager)
+    libraryService.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
     let syncService = SyncService()
     syncService.setup(isActive: true, libraryService: libraryService)
 
diff --git a/BookPlayer/Settings/Storage/StorageViewModel.swift b/BookPlayer/Settings/Storage/StorageViewModel.swift
index bbad01b11..bd08c66ea 100644
--- a/BookPlayer/Settings/Storage/StorageViewModel.swift
+++ b/BookPlayer/Settings/Storage/StorageViewModel.swift
@@ -166,10 +166,10 @@ final class StorageViewModel: StorageViewModelProtocol {
     publishedFiles.filter({ $0.showWarning })
   }
 
-  func handleFix(for item: StorageItem, shouldReloadItems: Bool = true) throws {
+  func handleFix(for item: StorageItem, shouldReloadItems: Bool = true) async throws {
     guard let fetchedBook = self.libraryService.findBooks(containing: item.fileURL)?.first else {
       // create a new book
-      try self.createBook(from: item)
+      try await self.createBook(from: item)
       if shouldReloadItems {
         self.loadItems()
       }
@@ -224,11 +224,15 @@ final class StorageViewModel: StorageViewModelProtocol {
   }
 
   func fixSelectedItem(_ item: StorageItem) {
-    do {
-      try handleFix(for: item)
-    } catch {
-      storageAlert = .error(errorMessage: error.localizedDescription)
-      showAlert = true
+    Task {
+      do {
+        try await handleFix(for: item)
+      } catch {
+        await MainActor.run {
+          storageAlert = .error(errorMessage: error.localizedDescription)
+          showAlert = true
+        }
+      }
     }
   }
 
@@ -361,8 +365,8 @@ final class StorageViewModel: StorageViewModelProtocol {
     listState.reloadAll()
   }
 
-  private func createBook(from item: StorageItem) throws {
-    let book = self.libraryService.createBook(from: item.fileURL)
+  private func createBook(from item: StorageItem) async throws {
+    let book = await self.libraryService.createBook(from: item.fileURL)
     try moveBookFile(from: item, with: book)
     try libraryService.moveItems([book.relativePath], inside: nil)
     reloadLibraryItems()
@@ -450,7 +454,7 @@ final class StorageViewModel: StorageViewModelProtocol {
   private func fixItemSafely(_ item: StorageItem) async -> FixResult {
     do {
       try await Task.detached(priority: .userInitiated) {
-        try self.handleFix(for: item, shouldReloadItems: false)
+        try await self.handleFix(for: item, shouldReloadItems: false)
       }.value
       
       return FixResult(item: item, success: true, error: nil)
diff --git a/BookPlayerTests/DataManagerTests.swift b/BookPlayerTests/DataManagerTests.swift
index c5861498b..102a32af9 100644
--- a/BookPlayerTests/DataManagerTests.swift
+++ b/BookPlayerTests/DataManagerTests.swift
@@ -46,8 +46,9 @@ class ProcessFilesTests: DataManagerTests {
 
     let expectation = XCTestExpectation(description: "File import notification")
 
+    let audioMetadataService = AudioMetadataService()
     let libraryService = LibraryService()
-    libraryService.setup(dataManager: self.dataManager)
+    libraryService.setup(dataManager: self.dataManager, audioMetadataService: audioMetadataService)
     self.importManager = ImportManager(libraryService: libraryService)
 
     self.subscription = self.importManager.observeFiles().sink { files in
diff --git a/BookPlayerTests/ImportOperationTests.swift b/BookPlayerTests/ImportOperationTests.swift
index 72fbc3d3c..c537d628c 100644
--- a/BookPlayerTests/ImportOperationTests.swift
+++ b/BookPlayerTests/ImportOperationTests.swift
@@ -31,8 +31,9 @@ class ImportOperationTests: XCTestCase {
     let promise = XCTestExpectation(description: "Process file")
     let promiseFile = expectation(forNotification: .processingFile, object: nil)
     let dataManager = DataManager(coreDataStack: CoreDataStack(testPath: "/dev/null"))
+    let audioMetadataService = AudioMetadataService()
     let libraryService = LibraryService()
-    libraryService.setup(dataManager: dataManager)
+    libraryService.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
     let operation = ImportOperation(files: [fileUrl],
                                     libraryService: libraryService)
 
diff --git a/BookPlayerTests/PerformanceTests/PlaybackPerformanceTests.swift b/BookPlayerTests/PerformanceTests/PlaybackPerformanceTests.swift
index fbaaad775..f7a28996b 100644
--- a/BookPlayerTests/PerformanceTests/PlaybackPerformanceTests.swift
+++ b/BookPlayerTests/PerformanceTests/PlaybackPerformanceTests.swift
@@ -17,8 +17,9 @@ final class PlaybackPerformanceTests: XCTestCase {
   override func setUpWithError() throws {
     DataTestUtils.clearFolderContents(url: DataManager.getProcessedFolderURL())
     let dataManager = DataManager(coreDataStack: CoreDataStack(testPath: "/dev/null"))
+    let audioMetadataService = AudioMetadataService()
     self.sut = LibraryService()
-    self.sut.setup(dataManager: dataManager)
+    self.sut.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
     _ = self.sut.getLibrary()
   }
 
@@ -26,11 +27,11 @@ final class PlaybackPerformanceTests: XCTestCase {
     self.sut = nil
   }
 
-  func testFolderProgressUpdatePerformance() throws {
+  func testFolderProgressUpdatePerformance() async throws {
     /// Setup a test folder with 3000 ibooks inside it
     let folder = try self.sut.createFolder(with: "test-folder", inside: nil)
     let urls = Array(stride(from: 0, to: 3000, by: 1)).map({ URL(string: "test-book-\($0).mp3")! })
-    _ = self.sut.insertItems(from: urls, parentPath: folder.relativePath)
+    _ = await self.sut.insertItems(from: urls, parentPath: folder.relativePath)
 
     self.measure(metrics: [XCTCPUMetric()]) {
       /// This is called by the `PlayerManager` when the currently playing book changes its progress percentage
diff --git a/BookPlayerTests/Services/LibraryServiceTests.swift b/BookPlayerTests/Services/LibraryServiceTests.swift
index e24ab8cbd..09d8775cf 100644
--- a/BookPlayerTests/Services/LibraryServiceTests.swift
+++ b/BookPlayerTests/Services/LibraryServiceTests.swift
@@ -20,8 +20,9 @@ class LibraryServiceTests: XCTestCase {
   override func setUp() {
     DataTestUtils.clearFolderContents(url: DataManager.getProcessedFolderURL())
     let dataManager = DataManager(coreDataStack: CoreDataStack(testPath: "/dev/null"))
+    let audioMetadataService = AudioMetadataService()
     self.sut = LibraryService()
-    self.sut.setup(dataManager: dataManager)
+    self.sut.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
     _ = self.sut.getLibrary()
   }
 
@@ -71,14 +72,14 @@ class LibraryServiceTests: XCTestCase {
     XCTAssert(currentTheme?.title == "Default / Dark")
   }
 
-  func testCreateBook() {
+  func testCreateBook() async {
     let filename = "test-book.txt"
     let bookContents = "bookcontents".data(using: .utf8)!
     let processedFolder = DataManager.getProcessedFolderURL()
 
     // Add test file to Processed folder
     let fileUrl = DataTestUtils.generateTestFile(name: filename, contents: bookContents, destinationFolder: processedFolder)
-    let newBook = self.sut.createBook(from: fileUrl)
+    let newBook = await self.sut.createBook(from: fileUrl)
     XCTAssert(newBook.title == "test-book.txt")
     XCTAssert(newBook.relativePath == "test-book.txt")
   }
@@ -657,7 +658,7 @@ class InsertBooksTests: LibraryServiceTests {
     XCTAssert(library.items?.count == 0)
   }
 
-  func testInsertOneBookInLibrary() throws {
+  func testInsertOneBookInLibrary() async throws {
     let library = self.sut.getLibrary()
 
     let filename = "file.txt"
@@ -667,13 +668,13 @@ class InsertBooksTests: LibraryServiceTests {
     // Add test file to Processed folder
     let fileUrl = DataTestUtils.generateTestFile(name: filename, contents: bookContents, destinationFolder: processedFolder)
 
-    let processedItems = self.sut.insertItems(from: [fileUrl])
+    let processedItems = await self.sut.insertItems(from: [fileUrl])
 
     XCTAssert(library.items?.count == 1)
     XCTAssert(processedItems.count == 1)
   }
 
-  func testInsertMultipleBooksInLibrary() throws {
+  func testInsertMultipleBooksInLibrary() async throws {
     let library = self.sut.getLibrary()
 
     let filename1 = "file1.txt"
@@ -686,13 +687,13 @@ class InsertBooksTests: LibraryServiceTests {
     let file1Url = DataTestUtils.generateTestFile(name: filename1, contents: book1Contents, destinationFolder: processedFolder)
     let file2Url = DataTestUtils.generateTestFile(name: filename2, contents: book2Contents, destinationFolder: processedFolder)
 
-    let processedItems = self.sut.insertItems(from: [file1Url, file2Url])
+    let processedItems = await self.sut.insertItems(from: [file1Url, file2Url])
 
     XCTAssert(library.items?.count == 2)
     XCTAssert(processedItems.count == 2)
   }
 
-  func testInsertEmptyBooksIntoPlaylist() throws {
+  func testInsertEmptyBooksIntoPlaylist() async throws {
     let library = self.sut.getLibrary()
 
     _ = try self.sut.createFolder(with: "test-folder", inside: nil)
@@ -703,7 +704,7 @@ class InsertBooksTests: LibraryServiceTests {
     XCTAssert(folder.items?.count == 0)
   }
 
-  func testInsertOneBookIntoPlaylist() throws {
+  func testInsertOneBookIntoPlaylist() async throws {
     let library = self.sut.getLibrary()
 
     _ = try self.sut.createFolder(with: "test-folder", inside: nil)
@@ -718,7 +719,7 @@ class InsertBooksTests: LibraryServiceTests {
     // Add test file to Documents folder
     let fileUrl = DataTestUtils.generateTestFile(name: filename, contents: bookContents, destinationFolder: processedFolder)
 
-    let processedItems = sut.insertItems(from: [fileUrl])
+    let processedItems = await sut.insertItems(from: [fileUrl])
       .map({ $0.relativePath })
     try sut.moveItems(processedItems, inside: folder.relativePath)
     XCTAssert(library.items?.count == 1)
@@ -726,7 +727,7 @@ class InsertBooksTests: LibraryServiceTests {
     XCTAssert(processedItems.count == 1)
   }
 
-  func testInsertMultipleBooksIntoPlaylist() throws {
+  func testInsertMultipleBooksIntoPlaylist() async throws {
     let library = self.sut.getLibrary()
 
     _ = try self.sut.createFolder(with: "test-folder", inside: nil)
@@ -744,7 +745,7 @@ class InsertBooksTests: LibraryServiceTests {
     let file1Url = DataTestUtils.generateTestFile(name: filename1, contents: book1Contents, destinationFolder: processedFolder)
     let file2Url = DataTestUtils.generateTestFile(name: filename2, contents: book2Contents, destinationFolder: processedFolder)
 
-    let processedItems = sut.insertItems(from: [file1Url, file2Url])
+    let processedItems = await sut.insertItems(from: [file1Url, file2Url])
       .map({ $0.relativePath })
     try sut.moveItems(processedItems, inside: folder.relativePath)
 
@@ -753,7 +754,7 @@ class InsertBooksTests: LibraryServiceTests {
     XCTAssert(processedItems.count == 2)
   }
 
-  func testInsertExistingBookFromLibraryIntoPlaylist() throws {
+  func testInsertExistingBookFromLibraryIntoPlaylist() async throws {
     let library = self.sut.getLibrary()
 
     _ = try self.sut.createFolder(with: "test-folder", inside: nil)
@@ -768,7 +769,7 @@ class InsertBooksTests: LibraryServiceTests {
     // Add test file to Documents folder
     let fileUrl = DataTestUtils.generateTestFile(name: filename, contents: bookContents, destinationFolder: processedFolder)
 
-    let processedItems = self.sut.insertItems(from: [fileUrl])
+    let processedItems = await self.sut.insertItems(from: [fileUrl])
       .map({ $0.relativePath })
 
     XCTAssert(library.items?.count == 2)
@@ -780,7 +781,7 @@ class InsertBooksTests: LibraryServiceTests {
     XCTAssert(folder.items?.count == 1)
   }
 
-  func testInsertExistingBookFromPlaylistIntoLibrary() throws {
+  func testInsertExistingBookFromPlaylistIntoLibrary() async throws {
     let library = self.sut.getLibrary()
 
     _ = try self.sut.createFolder(with: "test-folder", inside: nil)
@@ -795,7 +796,7 @@ class InsertBooksTests: LibraryServiceTests {
     // Add test file to Documents folder
     let fileUrl = DataTestUtils.generateTestFile(name: filename, contents: bookContents, destinationFolder: processedFolder)
 
-    let processedItems = self.sut.insertItems(from: [fileUrl])
+    let processedItems = await self.sut.insertItems(from: [fileUrl])
       .map({ $0.relativePath })
 
     try self.sut.moveItems(processedItems, inside: folder.relativePath)
@@ -810,7 +811,7 @@ class InsertBooksTests: LibraryServiceTests {
     XCTAssert(folder.items?.count == 0)
   }
 
-  func testInsertExistingBookFromPlaylistIntoPlaylist() throws {
+  func testInsertExistingBookFromPlaylistIntoPlaylist() async throws {
     let library = self.sut.getLibrary()
 
     _ = try self.sut.createFolder(with: "test-folder1", inside: nil)
@@ -827,7 +828,7 @@ class InsertBooksTests: LibraryServiceTests {
     // Add test file to Processed folder
     let fileUrl = DataTestUtils.generateTestFile(name: filename, contents: bookContents, destinationFolder: processedFolder)
 
-    let processedItems = self.sut.insertItems(from: [fileUrl])
+    let processedItems = await self.sut.insertItems(from: [fileUrl])
       .map({ $0.relativePath })
 
     try self.sut.moveItems(processedItems, inside: folder1.relativePath)
diff --git a/BookPlayerTests/Support/StubFactory.swift b/BookPlayerTests/Support/StubFactory.swift
index b9502febf..07a60323f 100644
--- a/BookPlayerTests/Support/StubFactory.swift
+++ b/BookPlayerTests/Support/StubFactory.swift
@@ -59,8 +59,9 @@ class StubFactory {
   }
 
   public class func library(dataManager: DataManager) -> Library {
+    let audioMetadataService = AudioMetadataService()
     let libraryService = LibraryService()
-    libraryService.setup(dataManager: dataManager)
+    libraryService.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
     return libraryService.getLibrary()
   }
 }
diff --git a/BookPlayerWatch/ExtensionDelegate.swift b/BookPlayerWatch/ExtensionDelegate.swift
index 7536cffe4..e691ff895 100644
--- a/BookPlayerWatch/ExtensionDelegate.swift
+++ b/BookPlayerWatch/ExtensionDelegate.swift
@@ -67,8 +67,9 @@ class ExtensionDelegate: NSObject, WKApplicationDelegate, ObservableObject {
       let dataManager = DataManager(coreDataStack: stack)
       let accountService = AccountService()
       accountService.setup(dataManager: dataManager)
+      let audioMetadataService = AudioMetadataService()
       let libraryService = LibraryService()
-      libraryService.setup(dataManager: dataManager)
+      libraryService.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
       let syncService = SyncService()
       syncService.setup(
         isActive: accountService.hasSyncEnabled(),
diff --git a/Shared/Artwork/AVAudioAssetImageDataProvider.swift b/Shared/Artwork/AVAudioAssetImageDataProvider.swift
index 59fbf55f2..709d319f4 100644
--- a/Shared/Artwork/AVAudioAssetImageDataProvider.swift
+++ b/Shared/Artwork/AVAudioAssetImageDataProvider.swift
@@ -66,21 +66,23 @@ public struct AVAudioAssetImageDataProvider: ImageDataProvider {
   }
 
   private func extractDataFrom(url: URL) async throws -> Data {
-    let asset = AVAsset(url: url)
+    let asset = AVURLAsset(url: url)
 
-    await asset.loadValues(forKeys: ["metadata"])
+    do {
+      let metadata = try await asset.load(.metadata)
 
-    switch asset.statusOfValue(forKey: "metadata", error: nil) {
-    case .loaded:
       var imageData: Data?
 
       if url.pathExtension == "mp3" {
-        imageData = self.getDataFromMP3(asset: asset)
-      } else if let data = AVMetadataItem.metadataItems(
-        from: asset.commonMetadata,
-        filteredByIdentifier: .commonIdentifierArtwork
-      ).first?.dataValue {
-        imageData = data
+        imageData = await self.getDataFromMP3(metadata: metadata)
+      } else {
+        let commonMetadata = try await asset.load(.commonMetadata)
+        if let artworkItem = AVMetadataItem.metadataItems(
+          from: commonMetadata,
+          filteredByIdentifier: .commonIdentifierArtwork
+        ).first {
+          imageData = try? await artworkItem.load(.dataValue)
+        }
       }
 
       if let imageData {
@@ -88,18 +90,23 @@ public struct AVAudioAssetImageDataProvider: ImageDataProvider {
       }
 
       throw ProviderError.missingImage
-    default:
+    } catch is CancellationError {
+      throw ProviderError.metadataFailed
+    } catch let error as ProviderError {
+      throw error
+    } catch {
       throw ProviderError.metadataFailed
     }
   }
 
-  private func getDataFromMP3(asset: AVAsset) -> Data? {
-    for item in asset.metadata {
+  private func getDataFromMP3(metadata: [AVMetadataItem]) async -> Data? {
+    for item in metadata {
       guard let key = item.commonKey?.rawValue,
-            key == "artwork",
-            let value = item.value as? Data else { continue }
+            key == "artwork" else { continue }
 
-      return value
+      if let value = try? await item.load(.dataValue) {
+        return value
+      }
     }
 
     return nil
diff --git a/Shared/CoreData/Backed-Models/Book+CoreDataClass.swift b/Shared/CoreData/Backed-Models/Book+CoreDataClass.swift
index abfce8a84..842f7df76 100644
--- a/Shared/CoreData/Backed-Models/Book+CoreDataClass.swift
+++ b/Shared/CoreData/Backed-Models/Book+CoreDataClass.swift
@@ -56,140 +56,19 @@ extension CodingUserInfoKey {
 }
 
 extension Book {
-  public func loadChaptersIfNeeded(from asset: AVAsset, context: NSManagedObjectContext) -> Bool {
-    guard chapters?.count == 0 else { return false }
-
-    setChapters(from: asset, context: context)
-    return true
-  }
-
-  public func setChapters(from asset: AVAsset, context: NSManagedObjectContext) {
-    if !asset.availableChapterLocales.isEmpty {
-      setStandardChapters(from: asset, context: context)
-    } else {
-      setOverdriveChapters(from: asset, context: context)
-    }
-  }
-
-  /// Store chapters that are automatically parsed by the native SDK
-  private func setStandardChapters(from asset: AVAsset, context: NSManagedObjectContext) {
-    for locale in asset.availableChapterLocales {
-      let chaptersMetadata = asset.chapterMetadataGroups(
-        withTitleLocale: locale, containingItemsWithCommonKeys: [AVMetadataKey.commonKeyArtwork]
-      )
-
-      for (index, chapterMetadata) in chaptersMetadata.enumerated() {
-        let chapterIndex = index + 1
-        let chapter = Chapter(context: context)
-
-        chapter.title = AVMetadataItem.metadataItems(
-          from: chapterMetadata.items,
-          withKey: AVMetadataKey.commonKeyTitle,
-          keySpace: AVMetadataKeySpace.common).first?.value?.copy(with: nil) as? String ?? ""
-        chapter.start = CMTimeGetSeconds(chapterMetadata.timeRange.start)
-        chapter.duration = CMTimeGetSeconds(chapterMetadata.timeRange.duration)
-        chapter.index = Int16(chapterIndex)
-
-        self.addToChapters(chapter)
-      }
-    }
-  }
-
-  /// Try to store chapters info from the TXXX tag for mp3s (used by Overdrive)
-  /// Note: `XMLParser` does not have an async/await API, so I would rather use regex with
-  /// what was introduced in iOS 16 to parse the info
-  private func setOverdriveChapters(from asset: AVAsset, context: NSManagedObjectContext) {
-    guard
-      let fileURL,
-      fileURL.pathExtension == "mp3",
-      let overdriveMetadata = asset.metadata.first(where: { $0.identifier?.rawValue == "id3/TXXX" })?.value as? String
-    else { return }
-
-    let matches = overdriveMetadata.matches(of: /<Marker>(.+?)<\/Marker>/)
-    var chapters = [Chapter]()
-
-    for (index, match) in matches.enumerated() {
-      let (_, marker) = match.output
-
-      guard let (_, timeMatch) = marker.matches(of: /<Time>(.+?)<\/Time>/).first?.output else {
-        continue
-      }
-
-      let chapter = Chapter(context: context)
-      chapter.index = Int16(index + 1)
-      chapter.start = TimeParser.getDuration(from: String(timeMatch))
-
-      if let (_, nameMatch) = marker.matches(of: /<Name>(.+?)<\/Name>/).first?.output {
-        chapter.title = String(nameMatch)
-      } else {
-        chapter.title = ""
-      }
-
-      chapters.append(chapter)
-    }
-
-    /// Overdrive markers do not include the duration, we have to parse it from the next chapter over
-    for (index, chapter) in chapters.enumerated() {
-      if index == chapters.endIndex - 1 {
-        chapter.duration = self.duration - chapter.start
-      } else {
-        chapter.duration = chapters[index + 1].start - chapter.start
-      }
-
-      self.addToChapters(chapter)
-    }
-  }
+  public class func getBookTitle(from fileURL: URL) -> String {
+    let asset = AVAsset(url: fileURL)
 
-  private func loadMp3Data(from asset: AVAsset) {
+    // Check all metadata items for title, regardless of format
     for item in asset.metadata {
-      guard let key = item.commonKey?.rawValue,
-            let value = item.value else { continue }
-
-      switch key {
-      case "title":
-        self.title = value as? String
-      case "artist":
-        if self.details == "voiceover_unknown_author".localized {
-          self.details = value as? String
-        }
-      default:
-        continue
+      if let commonKey = item.commonKey?.rawValue,
+         commonKey == "title",
+         let title = item.value as? String {
+        return title
       }
     }
-  }
-
-  public convenience init(from bookUrl: URL, context: NSManagedObjectContext) {
-    let entity = NSEntityDescription.entity(forEntityName: "Book", in: context)!
-    self.init(entity: entity, insertInto: context)
-    let fileURL = bookUrl
-    self.relativePath = fileURL.relativePath(to: DataManager.getProcessedFolderURL())
-    self.remoteURL = nil
-    self.artworkURL = nil
-    let asset = AVAsset(url: fileURL)
-
-    let titleFromMeta = AVMetadataItem.metadataItems(from: asset.metadata, withKey: AVMetadataKey.commonKeyTitle, keySpace: AVMetadataKeySpace.common).first?.value?.copy(with: nil) as? String
-    let authorFromMeta = AVMetadataItem.metadataItems(from: asset.metadata, withKey: AVMetadataKey.commonKeyArtist, keySpace: AVMetadataKeySpace.common).first?.value?.copy(with: nil) as? String
-
-    self.title = titleFromMeta ?? bookUrl.lastPathComponent.replacingOccurrences(of: "_", with: " ")
-    self.details = authorFromMeta ?? "voiceover_unknown_author".localized
-    self.duration = CMTimeGetSeconds(asset.duration)
-    self.originalFileName = bookUrl.lastPathComponent
-    self.isFinished = false
-    self.type = .book
-
-    if fileURL.pathExtension == "mp3" {
-      self.loadMp3Data(from: asset)
-    }
-
-    self.setChapters(from: asset, context: context)
-  }
-
-  public class func getBookTitle(from fileURL: URL) -> String {
-    let asset = AVAsset(url: fileURL)
-
-    let titleFromMeta = AVMetadataItem.metadataItems(from: asset.metadata, withKey: AVMetadataKey.commonKeyTitle, keySpace: AVMetadataKeySpace.common).first?.value?.copy(with: nil) as? String
 
-    return titleFromMeta ?? fileURL.lastPathComponent
+    return fileURL.lastPathComponent
   }
 }
 
diff --git a/Shared/CoreData/DatabaseInitializer.swift b/Shared/CoreData/DatabaseInitializer.swift
index 549a3fd00..5b471f985 100644
--- a/Shared/CoreData/DatabaseInitializer.swift
+++ b/Shared/CoreData/DatabaseInitializer.swift
@@ -80,8 +80,9 @@ public class DatabaseInitializer: BPLogger {
           continuation.resume(throwing: error)
         } else {
           let dataManager = DataManager(coreDataStack: stack)
+          let audioMetadataService = AudioMetadataService()
           let libraryService = LibraryService()
-          libraryService.setup(dataManager: dataManager)
+          libraryService.setup(dataManager: dataManager, audioMetadataService: audioMetadataService)
           _ = libraryService.getLibrary()
 
           continuation.resume(returning: stack)
diff --git a/Shared/Services/AudioMetadataService.swift b/Shared/Services/AudioMetadataService.swift
index 6f1c491a0..4a386e6fa 100644
--- a/Shared/Services/AudioMetadataService.swift
+++ b/Shared/Services/AudioMetadataService.swift
@@ -7,20 +7,46 @@
 //
 
 import AVFoundation
+import CoreMedia
+
+public struct ChapterMetadata {
+  public let title: String
+  public let start: TimeInterval
+  public let duration: TimeInterval
+  public let index: Int
+  
+  public init(
+    title: String,
+    start: TimeInterval,
+    duration: TimeInterval,
+    index: Int
+  ) {
+    self.title = title
+    self.start = start
+    self.duration = duration
+    self.index = index
+  }
+}
 
 public struct AudioMetadata {
   public let title: String
   public let artist: String
+  public let duration: TimeInterval
   public let artwork: Data?
+  public let chapters: [ChapterMetadata]?
   
   public init(
     title: String,
     artist: String = "",
-    artwork: Data? = nil
+    duration: TimeInterval = 0,
+    artwork: Data? = nil,
+    chapters: [ChapterMetadata]? = nil
   ) {
     self.title = title
     self.artist = artist
+    self.duration = duration
     self.artwork = artwork
+    self.chapters = chapters
   }
 }
 
@@ -29,6 +55,11 @@ public protocol AudioMetadataServiceProtocol {
   /// - Parameter fileURL: URL to the audio file
   /// - Returns: AudioMetadata if extraction succeeds, nil otherwise
   func extractMetadata(from fileURL: URL) async -> AudioMetadata?
+
+  /// Extract metadata from an AVAsset
+  /// - Parameter asset: The AVAsset to extract metadata from
+  /// - Returns: AudioMetadata if extraction succeeds, nil otherwise
+  func extractMetadata(from asset: AVAsset) async -> AudioMetadata?
 }
 
 public class AudioMetadataService: BPLogger, AudioMetadataServiceProtocol {
@@ -36,47 +67,53 @@ public class AudioMetadataService: BPLogger, AudioMetadataServiceProtocol {
   public init() {}
   
   public func extractMetadata(from fileURL: URL) async -> AudioMetadata? {
+    let asset = AVURLAsset(url: fileURL)
+    return await extractMetadata(from: asset)
+  }
+  
+  public func extractMetadata(from asset: AVAsset) async -> AudioMetadata? {
     do {
-      let asset = AVAsset(url: fileURL)
       let metadata = try await asset.load(.metadata)
+      let duration = try await asset.load(.duration)
+      let durationSeconds = CMTimeGetSeconds(duration)
 
-      let title = await extractTitle(from: metadata) ?? fileURL.deletingPathExtension().lastPathComponent
+      let title = await extractTitle(from: metadata)
       let artist = await extractArtist(from: metadata)
       let artwork = await extractArtwork(from: metadata)
+      let chapters = await extractChapters(from: asset, metadata: metadata, duration: durationSeconds)
 
       return AudioMetadata(
         title: title,
         artist: artist,
-        artwork: artwork
+        duration: durationSeconds,
+        artwork: artwork,
+        chapters: chapters
       )
 
     } catch {
-      Self.logger.error("Failed to extract metadata from audio file \(fileURL.lastPathComponent): \(error)")
+      Self.logger.error("Failed to extract metadata from audio asset: \(error)")
       return nil
     }
   }
   
-  private func extractTitle(from metadata: [AVMetadataItem]) async -> String? {
+  private func extractTitle(from metadata: [AVMetadataItem]) async -> String {
     let titleKeys: [AVMetadataKey] = [
-      .commonKeyAlbumName,
+      .commonKeyTitle,              // Actual title - should be first
+      .commonKeyAlbumName,          // Album name (fallback for audiobooks)
       .id3MetadataKeyAlbumTitle,
       .iTunesMetadataKeyAlbum,
-      .commonKeyTitle,
       .id3MetadataKeyOriginalAlbumTitle,
     ]
     
-    var title: String?
-
     for key in titleKeys {
       if let metadataItem = metadata.first(where: { $0.commonKey == key }),
          let titleValue = try? await metadataItem.load(.stringValue),
          !titleValue.isEmpty {
-        title = titleValue
-        break
+        return titleValue
       }
     }
     
-    return title
+    return ""
   }
   
   private func extractArtist(from metadata: [AVMetadataItem]) async -> String {
@@ -107,4 +144,245 @@ public class AudioMetadataService: BPLogger, AudioMetadataServiceProtocol {
     
     return try? await artworkItem.load(.dataValue)
   }
+  
+  // MARK: - Chapter Extraction
+  
+  private func extractChapters(from asset: AVAsset, metadata: [AVMetadataItem], duration: TimeInterval) async -> [ChapterMetadata]? {
+    do {
+      let availableChapterLocales = try await asset.load(.availableChapterLocales)
+
+      // First try: Native chapter support (works for M4B, some M4A, properly tagged files)
+      if !availableChapterLocales.isEmpty {
+        return await extractStandardChapters(from: asset, locales: availableChapterLocales)
+      }
+
+      // Second try: Check what metadata identifiers exist
+      let identifiers = metadata.compactMap { $0.identifier?.rawValue }
+
+      // FLAC/Vorbis chapters (CHAPTER tags)
+      if identifiers.contains(where: { $0.contains("CHAPTER") && !$0.contains("NAME") }) {
+        return await extractVorbisChapters(from: metadata, duration: duration)
+      }
+
+      // MP3 Overdrive chapters (ID3 TXXX tag)
+      if identifiers.contains("id3/TXXX") {
+        return await extractOverdriveChapters(from: metadata, duration: duration)
+      }
+
+      // MP3 standard chapters (ID3v2.3+ CHAP frames)
+      // Note: Currently AVFoundation doesn't fully expose CHAP frame data,
+      // but this may be supported in future iOS releases.
+      if identifiers.contains(where: { $0.hasPrefix("id3/CHAP") }) {
+        return await extractID3Chapters(from: metadata, duration: duration)
+      }
+
+      return nil
+    } catch {
+      Self.logger.error("Failed to extract chapters: \(error)")
+      return nil
+    }
+  }
+  
+  private func extractStandardChapters(from asset: AVAsset, locales: [Locale]) async -> [ChapterMetadata]? {
+    var allChapters: [ChapterMetadata] = []
+
+    for locale in locales {
+      do {
+        let chaptersMetadata = try await asset.loadChapterMetadataGroups(
+          withTitleLocale: locale,
+          containingItemsWithCommonKeys: [AVMetadataKey.commonKeyArtwork]
+        )
+
+        for (index, chapterMetadata) in chaptersMetadata.enumerated() {
+          let chapterIndex = index + 1
+
+          // Get title using async load API
+          let titleItem = AVMetadataItem.metadataItems(
+            from: chapterMetadata.items,
+            withKey: AVMetadataKey.commonKeyTitle,
+            keySpace: AVMetadataKeySpace.common
+          ).first
+          let title = (try? await titleItem?.load(.stringValue)) ?? ""
+
+          let start = CMTimeGetSeconds(chapterMetadata.timeRange.start)
+          let duration = CMTimeGetSeconds(chapterMetadata.timeRange.duration)
+
+          let chapter = ChapterMetadata(
+            title: title,
+            start: start,
+            duration: duration,
+            index: chapterIndex
+          )
+
+          allChapters.append(chapter)
+        }
+      } catch {
+        Self.logger.error("Failed to load chapter metadata for locale \(locale): \(error)")
+      }
+    }
+
+    return allChapters.isEmpty ? nil : allChapters
+  }
+  
+  private func extractVorbisChapters(from metadata: [AVMetadataItem], duration: TimeInterval) async -> [ChapterMetadata]? {
+    var chapterMap: [Int: (time: String?, name: String?)] = [:]
+
+    for item in metadata {
+      guard let identifier = item.identifier?.rawValue else { continue }
+
+      // Match CHAPTER001, CHAPTER002, etc. (without NAME suffix)
+      if let range = identifier.range(of: #"CHAPTER(\d+)$"#, options: .regularExpression) {
+        let matched = identifier[range]
+        let numberStr = matched.dropFirst(7) // Remove "CHAPTER" prefix
+        if let number = Int(numberStr) {
+          let time = try? await item.load(.stringValue)
+          chapterMap[number, default: (nil, nil)].time = time
+        }
+      }
+
+      // Match CHAPTER001NAME, CHAPTER002NAME, etc.
+      if let range = identifier.range(of: #"CHAPTER(\d+)NAME$"#, options: .regularExpression) {
+        let matched = identifier[range]
+        let numberStr = String(matched.dropFirst(7).dropLast(4)) // Remove "CHAPTER" and "NAME"
+        if let number = Int(numberStr) {
+          let name = try? await item.load(.stringValue)
+          chapterMap[number, default: (nil, nil)].name = name
+        }
+      }
+    }
+
+    // Sort by chapter number and create ChapterMetadata objects
+    let sortedChapters = chapterMap.sorted { $0.key < $1.key }
+    var chapters: [ChapterMetadata] = []
+
+    for (index, (_, data)) in sortedChapters.enumerated() {
+      guard let timeString = data.time else { continue }
+
+      let start = TimeParser.getDuration(from: timeString)
+      let chapterDuration: TimeInterval
+
+      // Calculate duration from next chapter or file duration
+      if index < sortedChapters.count - 1,
+         let nextTimeString = sortedChapters[index + 1].value.time {
+        chapterDuration = TimeParser.getDuration(from: nextTimeString) - start
+      } else {
+        chapterDuration = duration - start
+      }
+
+      let chapter = ChapterMetadata(
+        title: data.name ?? "",
+        start: start,
+        duration: chapterDuration,
+        index: index + 1
+      )
+
+      chapters.append(chapter)
+    }
+
+    return chapters.isEmpty ? nil : chapters
+  }
+
+  private func extractID3Chapters(from metadata: [AVMetadataItem], duration: TimeInterval) async -> [ChapterMetadata]? {
+    var chapterData: [(start: Double, title: String)] = []
+
+    for item in metadata {
+      guard let identifier = item.identifier?.rawValue,
+            identifier.hasPrefix("id3/CHAP") else { continue }
+
+      // Extract chapter start time and title from CHAP frame.
+      // CHAP timestamps are relative offsets from the start of the audio (not absolute dates).
+      // Note: AVFoundation may not fully expose CHAP frame timing data currently,
+      // but we attempt to load what's available for future compatibility.
+      if let numberValue = try? await item.load(.numberValue),
+         numberValue.doubleValue >= 0 {
+        let startTime = numberValue.doubleValue
+        let title = (try? await item.load(.stringValue)) ?? ""
+        chapterData.append((start: startTime, title: title))
+      }
+    }
+
+    // Sort chapters by start time
+    chapterData.sort { $0.start < $1.start }
+
+    var chapters: [ChapterMetadata] = []
+    for (index, data) in chapterData.enumerated() {
+      let chapterDuration: TimeInterval
+
+      // Calculate duration
+      if index < chapterData.count - 1 {
+        chapterDuration = chapterData[index + 1].start - data.start
+      } else {
+        chapterDuration = duration - data.start
+      }
+
+      let chapter = ChapterMetadata(
+        title: data.title,
+        start: data.start,
+        duration: chapterDuration,
+        index: index + 1
+      )
+
+      chapters.append(chapter)
+    }
+
+    return chapters.isEmpty ? nil : chapters
+  }
+
+  private func extractOverdriveChapters(from metadata: [AVMetadataItem], duration: TimeInterval) async -> [ChapterMetadata]? {
+    guard let txxxItem = metadata.first(where: { $0.identifier?.rawValue == "id3/TXXX" }),
+          let overdriveMetadata = try? await txxxItem.load(.stringValue)
+    else { return nil }
+
+    let matches = overdriveMetadata.matches(of: /<Marker>(.+?)<\/Marker>/)
+    var chapters: [ChapterMetadata] = []
+
+    for (index, match) in matches.enumerated() {
+      let (_, marker) = match.output
+
+      guard let (_, timeMatch) = marker.matches(of: /<Time>(.+?)<\/Time>/).first?.output else {
+        continue
+      }
+
+      let start = TimeParser.getDuration(from: String(timeMatch))
+      let title: String
+      
+      if let (_, nameMatch) = marker.matches(of: /<Name>(.+?)<\/Name>/).first?.output {
+        title = String(nameMatch)
+      } else {
+        title = ""
+      }
+      
+      let chapter = ChapterMetadata(
+        title: title,
+        start: start,
+        duration: 0, // Will be calculated below
+        index: index + 1
+      )
+
+      chapters.append(chapter)
+    }
+
+    // Overdrive markers do not include the duration, we have to parse it from the next chapter over
+    var finalChapters: [ChapterMetadata] = []
+    for (index, chapter) in chapters.enumerated() {
+      let chapterDuration: TimeInterval
+      
+      if index == chapters.endIndex - 1 {
+        chapterDuration = duration - chapter.start
+      } else {
+        chapterDuration = chapters[index + 1].start - chapter.start
+      }
+      
+      let updatedChapter = ChapterMetadata(
+        title: chapter.title,
+        start: chapter.start,
+        duration: chapterDuration,
+        index: chapter.index
+      )
+
+      finalChapters.append(updatedChapter)
+    }
+
+    return finalChapters.isEmpty ? nil : finalChapters
+  }
 }
diff --git a/Shared/Services/LibraryService.swift b/Shared/Services/LibraryService.swift
index 0c20ba05f..e4b0081d7 100644
--- a/Shared/Services/LibraryService.swift
+++ b/Shared/Services/LibraryService.swift
@@ -33,7 +33,7 @@ public protocol LibraryServiceProtocol: AnyObject {
   /// Set the last played book
   func setLibraryLastBook(with relativePath: String?)
   /// Import and insert items
-  func insertItems(from files: [URL]) -> [SimpleLibraryItem]
+  func insertItems(from files: [URL]) async -> [SimpleLibraryItem]
   /// Move items between folders
   func moveItems(_ items: [String], inside relativePath: String?) throws
   /// Delete items
@@ -82,7 +82,7 @@ public protocol LibraryServiceProtocol: AnyObject {
 
   /// Update metadata
   /// Create book core data object
-  func createBook(from url: URL) -> Book
+  func createBook(from url: URL) async -> Book
   /// Load metadata chapters if needed
   func loadChaptersIfNeeded(relativePath: String, asset: AVAsset) async
   /// Create folder
@@ -153,6 +153,7 @@ public protocol LibraryServiceProtocol: AnyObject {
 @Observable
 public final class LibraryService: LibraryServiceProtocol, @unchecked Sendable {
   var dataManager: DataManager!
+  var audioMetadataService: AudioMetadataServiceProtocol!
 
   /// Internal passthrough publisher for emitting metadata update events
   private var metadataPassthroughPublisher = PassthroughSubject<[String: Any], Never>()
@@ -170,8 +171,9 @@ public final class LibraryService: LibraryServiceProtocol, @unchecked Sendable {
 
   public init() {}
 
-  public func setup(dataManager: DataManager) {
+  public func setup(dataManager: DataManager, audioMetadataService: AudioMetadataServiceProtocol) {
     self.dataManager = dataManager
+    self.audioMetadataService = audioMetadataService
 
     metadataUpdatePublisher =
       metadataPassthroughPublisher
@@ -570,14 +572,14 @@ extension LibraryService {
   }
 
   @discardableResult
-  public func insertItems(from files: [URL]) -> [SimpleLibraryItem] {
-    return insertItems(from: files, parentPath: nil)
+  public func insertItems(from files: [URL]) async -> [SimpleLibraryItem] {
+    return await insertItems(from: files, parentPath: nil)
   }
 
   /// This handles the Core Data objects creation from the Import operation. This method doesn't handle moving files on disk,
   /// as we don't want this method to throw, and the files are already in the processed folder
   @discardableResult
-  func insertItems(from files: [URL], parentPath: String? = nil) -> [SimpleLibraryItem] {
+  func insertItems(from files: [URL], parentPath: String? = nil) async -> [SimpleLibraryItem] {
     let context = dataManager.getContext()
     let library = getLibraryReference()
 
@@ -590,10 +592,20 @@ extension LibraryService {
         type == .typeDirectory
       {
         libraryItem = Folder(from: file, context: context)
-        /// Kick-off separate function to handle instatiating the folder contents
-        self.handleDirectory(file)
+        /// Handle folder contents and wait for completion to ensure proper metadata extraction
+        await self.handleDirectory(file)
       } else {
-        libraryItem = Book(from: file, context: context)
+        // Extract metadata FIRST (includes chapters)
+        let metadata = await audioMetadataService.extractMetadata(from: file)
+        
+        // Create Book with metadata
+        let book = createBook(from: file, metadata: metadata, context: context)
+        libraryItem = book
+        
+        // Create chapters immediately if available
+        if let chapters = metadata?.chapters {
+          storeChapters(chapters, for: book, context: context)
+        }
       }
 
       libraryItem.orderRank = getNextOrderRank(in: parentPath)
@@ -614,7 +626,45 @@ extension LibraryService {
     return processedFiles
   }
 
-  private func handleDirectory(_ folderURL: URL) {
+  private func createBook(from url: URL, metadata: AudioMetadata?, context: NSManagedObjectContext) -> Book {
+    let entity = NSEntityDescription.entity(forEntityName: "Book", in: context)!
+    let book = Book(entity: entity, insertInto: context)
+    
+    book.relativePath = url.relativePath(to: DataManager.getProcessedFolderURL())
+    book.remoteURL = nil
+    book.artworkURL = nil
+    let title = metadata?.title ?? ""
+    book.title = title.isEmpty ? url.lastPathComponent.replacingOccurrences(of: "_", with: " ") : title
+    let artist = metadata?.artist ?? ""
+    book.details = artist.isEmpty ? "voiceover_unknown_author".localized : artist
+    book.duration = metadata?.duration ?? 0
+    book.originalFileName = url.lastPathComponent
+    book.isFinished = false
+    book.type = .book
+    
+    return book
+  }
+  
+  private func storeChapters(_ chapters: [ChapterMetadata], for book: Book, context: NSManagedObjectContext) {
+    for chapterMeta in chapters {
+      let chapter = Chapter(context: context)
+      chapter.title = chapterMeta.title
+      chapter.start = chapterMeta.start
+      chapter.duration = chapterMeta.duration
+      chapter.index = Int16(chapterMeta.index)
+      book.addToChapters(chapter)
+    }
+  }
+  
+  /// Overload for backwards compatibility when we need to query by relativePath
+  private func storeChapters(_ chapters: [ChapterMetadata], for relativePath: String, context: NSManagedObjectContext) {
+    guard let book = getItem(with: relativePath, context: context) as? Book else {
+      return
+    }
+    storeChapters(chapters, for: book, context: context)
+  }
+
+  private func handleDirectory(_ folderURL: URL) async {
     let enumerator = FileManager.default.enumerator(
       at: folderURL,
       includingPropertiesForKeys: [.isDirectoryKey],
@@ -640,7 +690,7 @@ extension LibraryService {
     let sortedFiles = orderedSet.sortedArray(using: [sortDescriptor]) as! [URL]
 
     let parentPath = folderURL.relativePath(to: DataManager.getProcessedFolderURL())
-    insertItems(from: sortedFiles, parentPath: parentPath)
+    _ = await insertItems(from: sortedFiles, parentPath: parentPath)
     rebuildFolderDetails(parentPath)
   }
 
@@ -1320,31 +1370,51 @@ extension LibraryService {
 
 // MARK: - Metadata update
 extension LibraryService {
-  public func createBook(from url: URL) -> Book {
+  public func createBook(from url: URL) async -> Book {
     let context = dataManager.getContext()
-    let newBook = Book(from: url, context: context)
+    
+    // Extract metadata using the new service
+    let metadata = await audioMetadataService.extractMetadata(from: url)
+    
+    // Create book with extracted metadata
+    let newBook = createBook(from: url, metadata: metadata, context: context)
+    
+    // Store chapters if available
+    if let chapters = metadata?.chapters {
+      storeChapters(chapters, for: newBook, context: context)
+    }
+    
     self.dataManager.saveSyncContext(context)
     return newBook
   }
 
   public func loadChaptersIfNeeded(relativePath: String, asset: AVAsset) async {
-    return await withCheckedContinuation { continuation in
-      let context = dataManager.getBackgroundContext()
-      context.perform { [unowned self, context] in
-        guard
-          let book = getItem(with: relativePath, context: context) as? Book
-        else {
-          continuation.resume()
-          return
-        }
+    let context = dataManager.getBackgroundContext()
 
-        let hadEmptyChapters = book.loadChaptersIfNeeded(from: asset, context: context)
+    // First, check if we need to load chapters
+    let needsChapters = await context.perform { [unowned self] in
+      guard let book = self.getItem(with: relativePath, context: context) as? Book else {
+        return false
+      }
+      return book.chapters?.count == 0
+    }
 
-        if hadEmptyChapters {
-          dataManager.saveSyncContext(context)
-        }
-        continuation.resume()
+    guard needsChapters else { return }
+
+    // Extract metadata outside of context.perform
+    guard let metadata = await audioMetadataService.extractMetadata(from: asset),
+          let chapters = metadata.chapters else {
+      return
+    }
+
+    // Store chapters in the context, re-checking if still needed to avoid race conditions
+    await context.perform { [unowned self] in
+      guard let book = self.getItem(with: relativePath, context: context) as? Book,
+            book.chapters?.count == 0 else {
+        return
       }
+      self.storeChapters(chapters, for: book, context: context)
+      self.dataManager.saveSyncContext(context)
     }
   }