@mmerterden/multi-agent-pipeline 20.35.0 → 20.37.0

package/pipeline/skills/shared/external/compose-navigation/references/code-examples.md

@@ -0,0 +1,70 @@
+# Compose Navigation Code Examples
+
+Full code samples for the SKILL.md sections that link here. The rules and the decision guidance stay in SKILL.md; each heading below matches the SKILL.md section the code belongs to.
+
+## Bottom Navigation
+
+```kotlin
+@Serializable
+object HomeRoute
+
+@Serializable
+object SearchRoute
+
+@Serializable
+object ProfileRoute
+
+enum class TopLevelDestination(
+    val label: String,
+    val icon: ImageVector,
+    val route: Any,
+) {
+    HOME("Home", Icons.Default.Home, HomeRoute),
+    SEARCH("Search", Icons.Default.Search, SearchRoute),
+    PROFILE("Profile", Icons.Default.Person, ProfileRoute),
+}
+
+@Composable
+fun MainScreen() {
+    val navController = rememberNavController()
+    val currentBackStackEntry by navController.currentBackStackEntryAsState()
+
+    Scaffold(
+        bottomBar = {
+            NavigationBar {
+                TopLevelDestination.entries.forEach { destination ->
+                    val isSelected = currentBackStackEntry
+                        ?.destination?.hasRoute(destination.route::class) == true
+
+                    NavigationBarItem(
+                        selected = isSelected,
+                        onClick = {
+                            navController.navigate(destination.route) {
+                                popUpTo(navController.graph.findStartDestination().id) {
+                                    saveState = true
+                                }
+                                launchSingleTop = true
+                                restoreState = true
+                            }
+                        },
+                        icon = {
+                            Icon(destination.icon, contentDescription = destination.label)
+                        },
+                        label = { Text(destination.label) },
+                    )
+                }
+            }
+        },
+    ) { innerPadding ->
+        NavHost(
+            navController = navController,
+            startDestination = HomeRoute,
+            modifier = Modifier.padding(innerPadding),
+        ) {
+            composable<HomeRoute> { HomeScreen() }
+            composable<SearchRoute> { SearchScreen() }
+            composable<ProfileRoute> { ProfileScreen() }
+        }
+    }
+}
+```

package/pipeline/skills/shared/external/core-data/SKILL.md

@@ -151,46 +151,11 @@ Batch requests run directly against SQLite. They skip the context, which makes
 them fast, but they post no context notifications, so **merge their results
 yourself**.
 
-```swift
-@Sendable func publish(_ result: Any?, as key: String) {
-    let ids = result as? [NSManagedObjectID] ?? []
-    let ui = LibraryStore.shared.container.viewContext
-    NSManagedObjectContext.mergeChanges(fromRemoteContextSave: [key: ids], into: [ui])
-}
-
-let worker = LibraryStore.shared.makeWorker()
-
-// Insert (iOS 13+)
-try await worker.perform {
-    let insert = NSBatchInsertRequest(entity: Book.entity(), objects: rows.map { ["isbn": $0.isbn, "title": $0.title] })
-    insert.resultType = .objectIDs
-    let inserted = try worker.execute(insert) as? NSBatchInsertResult
-    publish(inserted?.result, as: NSInsertedObjectsKey)
-}
-
-// Delete (iOS 9+)
-try await worker.perform {
-    let stale: NSFetchRequest<NSFetchRequestResult> = Loan.fetchRequest()
-    stale.predicate = NSPredicate(format: "returnedAt < %@", cutoff as NSDate)
-    let delete = NSBatchDeleteRequest(fetchRequest: stale)
-    delete.resultType = .resultTypeObjectIDs
-    let removed = try worker.execute(delete) as? NSBatchDeleteResult
-    publish(removed?.result, as: NSDeletedObjectsKey)
-}
-
-// Update (iOS 8+)
-try await worker.perform {
-    let update = NSBatchUpdateRequest(entity: Book.entity())
-    update.propertiesToUpdate = ["isArchived": true]
-    update.resultType = .updatedObjectIDsResultType
-    let changed = try worker.execute(update) as? NSBatchUpdateResult
-    publish(changed?.result, as: NSUpdatedObjectsKey)
-}
-```
-
 A batch delete does not honor the **Deny** delete rule and skips validation
 beyond the basic delete rules. Check those constraints yourself first.
 
+Code for this section: [Core Data code patterns](references/core-data-code.md).
+
 ## Persistent history
 
 History tracking records store-level changes so the app, its extensions and
@@ -214,58 +179,6 @@ container.persistentStoreDescriptions = [description]
 3. Merge each transaction into `viewContext` and move the token forward.
 4. Purge history older than the token.
 
-```swift
-final class HistoryReader: NSObject, @unchecked Sendable {
-    private let container: NSPersistentContainer
-    private let worker: NSManagedObjectContext
-    private let tokenKey: String            // one per target: "history.app", "history.widget"
-    private var lastToken: NSPersistentHistoryToken?
-
-    init(container: NSPersistentContainer, target: String) {
-        self.container = container
-        self.worker = container.newBackgroundContext()
-        self.tokenKey = "history.\(target)"
-        super.init()
-        lastToken = Self.loadToken(forKey: tokenKey)
-        let center = NotificationCenter.default
-        center.addObserver(self, selector: #selector(storeChanged),
-                           name: .NSPersistentStoreRemoteChange, object: container.persistentStoreCoordinator)
-    }
-
-    @objc private func storeChanged(_ note: Notification) {
-        worker.perform { [self] in
-            let fetch = NSPersistentHistoryChangeRequest.fetchHistory(after: lastToken)
-            let history = try? worker.execute(fetch) as? NSPersistentHistoryResult
-            guard let transactions = history?.result as? [NSPersistentHistoryTransaction] else { return }
-            let ui = container.viewContext
-            for transaction in transactions {
-                let changes = transaction.objectIDNotification().userInfo ?? [:]
-                NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [ui])
-                lastToken = transaction.token
-            }
-            Self.saveToken(lastToken, forKey: tokenKey)
-            if let lastToken {
-                _ = try? worker.execute(NSPersistentHistoryChangeRequest.deleteHistory(before: lastToken))
-            }
-        }
-    }
-
-    private static var defaults: UserDefaults { UserDefaults(suiteName: "group.app.library") ?? .standard }
-
-    private static func loadToken(forKey key: String) -> NSPersistentHistoryToken? {
-        defaults.data(forKey: key).flatMap {
-            try? NSKeyedUnarchiver.unarchivedObject(ofClass: NSPersistentHistoryToken.self, from: $0)
-        }
-    }
-
-    private static func saveToken(_ token: NSPersistentHistoryToken?, forKey key: String) {
-        guard let token else { return }
-        let encoded = try? NSKeyedArchiver.archivedData(withRootObject: token, requiringSecureCoding: true)
-        defaults.set(encoded, forKey: key)
-    }
-}
-```
-
 `@unchecked Sendable` rests on one guarantee: after `init` (which sets
 `lastToken` before the observer is registered), `lastToken` is read and written
 only inside `worker.perform`, and one context runs its `perform` blocks one at a
@@ -281,6 +194,8 @@ Keep one token per target (for example in the shared `UserDefaults` suite) so
 each process resumes where it stopped after relaunch. Purge only up to the
 point every reader has consumed.
 
+Code for this section: [Core Data code patterns](references/core-data-code.md).
+
 ## Staged migration (iOS 17+)
 
 `NSStagedMigrationManager` applies an ordered list of stages, each either
@@ -292,40 +207,6 @@ lightweight or custom.
 - `NSCustomMigrationStage(migratingFrom:to:)` takes a source and a destination
   reference and offers `label` and `willMigrateHandler` (called with the manager and stage).
 
-```swift
-let v1 = NSManagedObjectModelReference(name: "Library_v1", in: .main, versionChecksum: "k3Qp...v1")
-let v2 = NSManagedObjectModelReference(name: "Library_v2", in: .main, versionChecksum: "R8bz...v2")
-let v3Checksum = "Yt5m...v3"
-
-let splitAuthor = NSCustomMigrationStage(migratingFrom: v1, to: v2)
-splitAuthor.label = "Split author into first and last name"
-splitAuthor.willMigrateHandler = { manager, _ in
-    guard let store = manager.container else { return }
-    let context = store.newBackgroundContext()
-    try context.performAndWait {
-        let request = NSFetchRequest<NSManagedObject>(entityName: "Book")
-        for book in try context.fetch(request) {
-            let full = book.value(forKey: "author") as? String ?? ""
-            let parts = full.split(separator: " ", maxSplits: 1).map(String.init)
-            book.setValue(parts.first, forKey: "authorFirst")
-            book.setValue(parts.count > 1 ? parts[1] : nil, forKey: "authorLast")
-        }
-        try context.save()
-    }
-}
-
-let addIndexes = NSLightweightMigrationStage([v3Checksum])
-addIndexes.label = "v2 to v3: add indexes"
-
-let manager = NSStagedMigrationManager([splitAuthor, addIndexes])
-let description = container.persistentStoreDescriptions.first ?? NSPersistentStoreDescription()
-description.setOption(manager, forKey: NSPersistentStoreStagedMigrationManagerOptionKey)
-container.persistentStoreDescriptions = [description]
-container.loadPersistentStores { _, error in
-    if let error { MigrationLog.failed(error) }
-}
-```
-
 The option must be on the store description **before** `loadPersistentStores`.
 Read the checksums from the compiled `.momd` (for example
 `NSManagedObjectModel.versionChecksum`), never type a model name in their place.
@@ -333,6 +214,8 @@ Read the checksums from the compiled `.momd` (for example
 Older deployment targets fall back to inferred mapping
 (`NSInferMappingModelAutomaticallyOption`) or hand-written mapping models.
 
+Code for this section: [Core Data code patterns](references/core-data-code.md).
+
 ## Composite attributes (iOS 17+)
 
 `NSCompositeAttributeDescription` groups several sub-attributes into one
@@ -353,44 +236,12 @@ from this side:
 
 ## Testing with an in-memory store
 
-```swift
-import Testing
-import CoreData
-
-enum TestModel {
-    nonisolated(unsafe) static let shared: NSManagedObjectModel = {   // loaded once, never mutated
-        let compiled = Bundle(for: LibraryStore.self).url(forResource: "Library", withExtension: "momd")
-        return compiled.flatMap(NSManagedObjectModel.init(contentsOf:)) ?? NSManagedObjectModel()
-    }()
-}
-
-func makeMemoryContainer() throws -> NSPersistentContainer {
-    let container = NSPersistentContainer(name: "Library", managedObjectModel: TestModel.shared)
-    let memory = NSPersistentStoreDescription()
-    memory.type = NSInMemoryStoreType
-    container.persistentStoreDescriptions = [memory]
-    var failure: Error?
-    container.loadPersistentStores { _, problem in failure = problem }
-    if let failure { throw failure }
-    return container
-}
-
-@Test func savingABookPersistsIt() throws {
-    let context = try makeMemoryContainer().viewContext
-    let book = Book(context: context)
-    book.title = "Dune"
-    try context.save()
-
-    let fetched = try context.fetch(Book.fetchRequest())
-    #expect(fetched.count == 1)
-    #expect(fetched.first?.title == "Dune")
-}
-```
-
 Load the model once and pass the same `NSManagedObjectModel` to every test
 container; loading it per test produces "multiple entity descriptions claim"
 duplicate-entity warnings.
 
+Code for this section: [Core Data code patterns](references/core-data-code.md).
+
 ## Common mistakes
 
 | Mistake | Fix |
@@ -421,6 +272,7 @@ duplicate-entity warnings.
 
 ## References
 
+- [Core Data code patterns](references/core-data-code.md): open when writing batch requests, consuming persistent history, setting up staged migration or building an in-memory test container.
 - [Core Data](https://developer.apple.com/documentation/coredata)
 - [NSPersistentContainer](https://developer.apple.com/documentation/coredata/nspersistentcontainer)
 - [NSManagedObjectContext](https://developer.apple.com/documentation/coredata/nsmanagedobjectcontext)

package/pipeline/skills/shared/external/core-data/references/core-data-code.md

@@ -0,0 +1,221 @@
+# Core Data code patterns
+
+<!-- toc -->
+- [Batch requests](#batch-requests)
+- [Staged migration (iOS 17+)](#staged-migration-ios-17)
+- [Testing with an in-memory store](#testing-with-an-in-memory-store)
+<!-- /toc -->
+
+Full code for batch requests, persistent history consumption, staged migration and in-memory test containers. SKILL.md keeps the rules; this file holds the worked code.
+
+## Batch requests
+
+Batch requests run directly against SQLite. They skip the context, which makes
+them fast, but they post no context notifications, so **merge their results
+yourself**.
+
+```swift
+@Sendable func publish(_ result: Any?, as key: String) {
+    let ids = result as? [NSManagedObjectID] ?? []
+    let ui = LibraryStore.shared.container.viewContext
+    NSManagedObjectContext.mergeChanges(fromRemoteContextSave: [key: ids], into: [ui])
+}
+
+let worker = LibraryStore.shared.makeWorker()
+
+// Insert (iOS 13+)
+try await worker.perform {
+    let insert = NSBatchInsertRequest(entity: Book.entity(), objects: rows.map { ["isbn": $0.isbn, "title": $0.title] })
+    insert.resultType = .objectIDs
+    let inserted = try worker.execute(insert) as? NSBatchInsertResult
+    publish(inserted?.result, as: NSInsertedObjectsKey)
+}
+
+// Delete (iOS 9+)
+try await worker.perform {
+    let stale: NSFetchRequest<NSFetchRequestResult> = Loan.fetchRequest()
+    stale.predicate = NSPredicate(format: "returnedAt < %@", cutoff as NSDate)
+    let delete = NSBatchDeleteRequest(fetchRequest: stale)
+    delete.resultType = .resultTypeObjectIDs
+    let removed = try worker.execute(delete) as? NSBatchDeleteResult
+    publish(removed?.result, as: NSDeletedObjectsKey)
+}
+
+// Update (iOS 8+)
+try await worker.perform {
+    let update = NSBatchUpdateRequest(entity: Book.entity())
+    update.propertiesToUpdate = ["isArchived": true]
+    update.resultType = .updatedObjectIDsResultType
+    let changed = try worker.execute(update) as? NSBatchUpdateResult
+    publish(changed?.result, as: NSUpdatedObjectsKey)
+}
+```
+
+A batch delete does not honor the **Deny** delete rule and skips validation
+beyond the basic delete rules. Check those constraints yourself first.
+
+### Consume it
+
+1. Observe `.NSPersistentStoreRemoteChange`, with the container's persistent store coordinator as the object.
+2. On a background context, fetch transactions after your last token.
+3. Merge each transaction into `viewContext` and move the token forward.
+4. Purge history older than the token.
+
+```swift
+final class HistoryReader: NSObject, @unchecked Sendable {
+    private let container: NSPersistentContainer
+    private let worker: NSManagedObjectContext
+    private let tokenKey: String            // one per target: "history.app", "history.widget"
+    private var lastToken: NSPersistentHistoryToken?
+
+    init(container: NSPersistentContainer, target: String) {
+        self.container = container
+        self.worker = container.newBackgroundContext()
+        self.tokenKey = "history.\(target)"
+        super.init()
+        lastToken = Self.loadToken(forKey: tokenKey)
+        let center = NotificationCenter.default
+        center.addObserver(self, selector: #selector(storeChanged),
+                           name: .NSPersistentStoreRemoteChange, object: container.persistentStoreCoordinator)
+    }
+
+    @objc private func storeChanged(_ note: Notification) {
+        worker.perform { [self] in
+            let fetch = NSPersistentHistoryChangeRequest.fetchHistory(after: lastToken)
+            let history = try? worker.execute(fetch) as? NSPersistentHistoryResult
+            guard let transactions = history?.result as? [NSPersistentHistoryTransaction] else { return }
+            let ui = container.viewContext
+            for transaction in transactions {
+                let changes = transaction.objectIDNotification().userInfo ?? [:]
+                NSManagedObjectContext.mergeChanges(fromRemoteContextSave: changes, into: [ui])
+                lastToken = transaction.token
+            }
+            Self.saveToken(lastToken, forKey: tokenKey)
+            if let lastToken {
+                _ = try? worker.execute(NSPersistentHistoryChangeRequest.deleteHistory(before: lastToken))
+            }
+        }
+    }
+
+    private static var defaults: UserDefaults { UserDefaults(suiteName: "group.app.library") ?? .standard }
+
+    private static func loadToken(forKey key: String) -> NSPersistentHistoryToken? {
+        defaults.data(forKey: key).flatMap {
+            try? NSKeyedUnarchiver.unarchivedObject(ofClass: NSPersistentHistoryToken.self, from: $0)
+        }
+    }
+
+    private static func saveToken(_ token: NSPersistentHistoryToken?, forKey key: String) {
+        guard let token else { return }
+        let encoded = try? NSKeyedArchiver.archivedData(withRootObject: token, requiringSecureCoding: true)
+        defaults.set(encoded, forKey: key)
+    }
+}
+```
+
+`@unchecked Sendable` rests on one guarantee: after `init` (which sets
+`lastToken` before the observer is registered), `lastToken` is read and written
+only inside `worker.perform`, and one context runs its `perform` blocks one at a
+time on its private queue. Creating a new background context per notification
+would break that, because two notifications could then run on two queues at
+once.
+
+The static merge call is safe from the worker queue; calling
+`viewContext.mergeChanges(fromContextDidSave: transaction.objectIDNotification())`
+inside `viewContext.perform` is the equivalent instance form.
+
+Keep one token per target (for example in the shared `UserDefaults` suite) so
+each process resumes where it stopped after relaunch. Purge only up to the
+point every reader has consumed.
+
+## Staged migration (iOS 17+)
+
+`NSStagedMigrationManager` applies an ordered list of stages, each either
+lightweight or custom.
+
+- `NSLightweightMigrationStage` takes the **version checksums** (`[String]`) of
+  compiled model versions, not their names, and has a `label`.
+- `NSManagedObjectModelReference(name:in:versionChecksum:)` points to one model version.
+- `NSCustomMigrationStage(migratingFrom:to:)` takes a source and a destination
+  reference and offers `label` and `willMigrateHandler` (called with the manager and stage).
+
+```swift
+let v1 = NSManagedObjectModelReference(name: "Library_v1", in: .main, versionChecksum: "k3Qp...v1")
+let v2 = NSManagedObjectModelReference(name: "Library_v2", in: .main, versionChecksum: "R8bz...v2")
+let v3Checksum = "Yt5m...v3"
+
+let splitAuthor = NSCustomMigrationStage(migratingFrom: v1, to: v2)
+splitAuthor.label = "Split author into first and last name"
+splitAuthor.willMigrateHandler = { manager, _ in
+    guard let store = manager.container else { return }
+    let context = store.newBackgroundContext()
+    try context.performAndWait {
+        let request = NSFetchRequest<NSManagedObject>(entityName: "Book")
+        for book in try context.fetch(request) {
+            let full = book.value(forKey: "author") as? String ?? ""
+            let parts = full.split(separator: " ", maxSplits: 1).map(String.init)
+            book.setValue(parts.first, forKey: "authorFirst")
+            book.setValue(parts.count > 1 ? parts[1] : nil, forKey: "authorLast")
+        }
+        try context.save()
+    }
+}
+
+let addIndexes = NSLightweightMigrationStage([v3Checksum])
+addIndexes.label = "v2 to v3: add indexes"
+
+let manager = NSStagedMigrationManager([splitAuthor, addIndexes])
+let description = container.persistentStoreDescriptions.first ?? NSPersistentStoreDescription()
+description.setOption(manager, forKey: NSPersistentStoreStagedMigrationManagerOptionKey)
+container.persistentStoreDescriptions = [description]
+container.loadPersistentStores { _, error in
+    if let error { MigrationLog.failed(error) }
+}
+```
+
+The option must be on the store description **before** `loadPersistentStores`.
+Read the checksums from the compiled `.momd` (for example
+`NSManagedObjectModel.versionChecksum`), never type a model name in their place.
+
+Older deployment targets fall back to inferred mapping
+(`NSInferMappingModelAutomaticallyOption`) or hand-written mapping models.
+
+## Testing with an in-memory store
+
+```swift
+import Testing
+import CoreData
+
+enum TestModel {
+    nonisolated(unsafe) static let shared: NSManagedObjectModel = {   // loaded once, never mutated
+        let compiled = Bundle(for: LibraryStore.self).url(forResource: "Library", withExtension: "momd")
+        return compiled.flatMap(NSManagedObjectModel.init(contentsOf:)) ?? NSManagedObjectModel()
+    }()
+}
+
+func makeMemoryContainer() throws -> NSPersistentContainer {
+    let container = NSPersistentContainer(name: "Library", managedObjectModel: TestModel.shared)
+    let memory = NSPersistentStoreDescription()
+    memory.type = NSInMemoryStoreType
+    container.persistentStoreDescriptions = [memory]
+    var failure: Error?
+    container.loadPersistentStores { _, problem in failure = problem }
+    if let failure { throw failure }
+    return container
+}
+
+@Test func savingABookPersistsIt() throws {
+    let context = try makeMemoryContainer().viewContext
+    let book = Book(context: context)
+    book.title = "Dune"
+    try context.save()
+
+    let fetched = try context.fetch(Book.fetchRequest())
+    #expect(fetched.count == 1)
+    #expect(fetched.first?.title == "Dune")
+}
+```
+
+Load the model once and pass the same `NSManagedObjectModel` to every test
+container; loading it per test produces "multiple entity descriptions claim"
+duplicate-entity warnings.

package/pipeline/skills/shared/external/core-nfc/SKILL.md

@@ -61,48 +61,7 @@ disable the feature instead of starting a session that will fail.
 The NDEF session is the shortest path when all you need is a URL, some text or
 a MIME blob.
 
-```swift
-import CoreNFC
-
-final class BadgeReader: NSObject, NFCNDEFReaderSessionDelegate {
-    private var session: NFCNDEFReaderSession?
-
-    func scan() {
-        guard NFCNDEFReaderSession.readingAvailable else { return }
-        session = NFCNDEFReaderSession(
-            delegate: self,
-            queue: nil,
-            invalidateAfterFirstRead: false
-        )
-        session?.alertMessage = "Hold the top of your iPhone near the badge."
-        session?.begin()
-    }
-
-    func readerSessionDidBecomeActive(_ session: NFCNDEFReaderSession) {}
-
-    func readerSession(_ reader: NFCNDEFReaderSession, didDetectNDEFs found: [NFCNDEFMessage]) {
-        for message in found {
-            for record in message.records {
-                handle(record)
-            }
-        }
-    }
-
-    func readerSession(_ reader: NFCNDEFReaderSession, didInvalidateWithError error: any Error) {
-        if let nfcError = error as? NFCReaderError,
-           nfcError.code == .readerSessionInvalidationErrorFirstNDEFTagRead
-            || nfcError.code == .readerSessionInvalidationErrorUserCanceled {
-            // Normal end of a scan, not a failure.
-        } else {
-            report(error)
-        }
-        self.session = nil
-    }
-
-    private func handle(_ record: NFCNDEFPayload) {}
-    private func report(_ error: Error) {}
-}
-```
+Code: [Reading NDEF data](references/code-examples.md#reading-ndef-data).
 
 The first-read and user-cancel codes are ordinary endings. Only other codes
 deserve an alert, and the session reference is cleared in every case.
@@ -204,53 +163,7 @@ Payment application identifiers are off limits for this session. For eligible
 payment use cases in the EU, Apple documents a separate
 `NFCPaymentTagReaderSession`.
 
-```swift
-final class CardReader: NSObject, NFCTagReaderSessionDelegate {
-    private var session: NFCTagReaderSession?
-
-    func scan() {
-        guard NFCTagReaderSession.readingAvailable else { return }
-        session = NFCTagReaderSession(pollingOption: [.iso14443, .iso15693], delegate: self, queue: nil)
-        session?.alertMessage = "Hold your transit card near the phone."
-        session?.begin()
-    }
-
-    func tagReaderSessionDidBecomeActive(_ session: NFCTagReaderSession) {}
-
-    func tagReaderSession(_ reader: NFCTagReaderSession, didDetect found: [NFCTag]) {
-        if found.count > 1 {
-            retryAfterMultipleTags(reader)
-            return
-        }
-        guard !found.isEmpty else {
-            reader.restartPolling()
-            return
-        }
-        nonisolated(unsafe) let reader = reader
-        nonisolated(unsafe) let tags = found
-        Task {
-            let tag = tags[0]
-            do {
-                try await reader.connect(to: tag)
-            } catch {
-                reader.invalidate(errorMessage: error.localizedDescription)
-                return
-            }
-            switch tag {
-            case .iso7816(let card): await select(card, in: reader)
-            case .miFare(let chip): await inspect(chip, in: reader)
-            case .iso15693(let label): await readBlocks(label, in: reader)
-            case .feliCa(let card): await readSystemCodes(card, in: reader)
-            @unknown default: reader.invalidate(errorMessage: "This tag type is not handled.")
-            }
-        }
-    }
-
-    func tagReaderSession(_ reader: NFCTagReaderSession, didInvalidateWithError error: any Error) {
-        session = nil
-    }
-}
-```
+Code: [Native tag access](references/code-examples.md#native-tag-access).
 
 The task receives the whole `tags` array rather than a single `NFCTag`: with
 the enum value itself as the `nonisolated(unsafe)` copy, Swift 6.3 still
@@ -441,3 +354,4 @@ func scene(_ scene: UIScene, continue activity: NSUserActivity) {
   - keys: [formats entitlement](https://developer.apple.com/documentation/bundleresources/entitlements/com.apple.developer.nfc.readersession.formats),
     [ISO 7816 AIDs](https://developer.apple.com/documentation/bundleresources/information-property-list/com.apple.developer.nfc.readersession.iso7816.select-identifiers),
     [FeliCa system codes](https://developer.apple.com/documentation/bundleresources/information-property-list/com.apple.developer.nfc.readersession.felica.systemcodes)
+- [Code examples](references/code-examples.md): open for the full code behind Reading NDEF data, Native tag access.