         }
     
         group.notify(queue: self.searchQueue) {
+            // This read does not need to be protected by the queue given that
+            // there's no longer concurrent access at this point.
             let sorted = items.sorted { $0.score < $1.score }
             DispatchQueue.main.async {
                 completion(sorted)

                        continue
                    }
                    
                    collectionResult.append((
                        index: index,
                        score: totalScore / Double(scores.count),
                        results: propertyResults
                    ))
                }
                
                group.leave()

        
        var items = [SearchResult]()
        
        // Serialize writes to `items`, for thread safety.
        // This label is non-unique but that should be fine as we don't expect
        // to need to debug work items running on this queue.
        let itemsQueue = DispatchQueue(label: "fuse.items.queue")
        
        let group = DispatchGroup()
        let count = aList.count
        
        stride(from: 0, to: count, by: chunkSize).forEach { offset in
            let chunk = Array(aList[offset..<min(offset + chunkSize, count)])
            group.enter()
            self.searchQueue.async {
                for (index, item) in chunk.enumerated() {
                    if let result = self.search(pattern, in: item) {
                        // This write doesn't technically need to be `sync` but
                        // that simplifies coordination with the dispatch group
                        // and it should execute very quickly anyway.
                        itemsQueue.sync {
                            items.append((offset + index, result.score, result.ranges))
                        }
                    }
                }
                
