@mmerterden/multi-agent-pipeline 20.7.0 → 20.8.1

package/pipeline/skills/shared/external/core-nfc/references/nfc-patterns.md

@@ -1,47 +1,82 @@
-# CoreNFC Extended Patterns
+# Core NFC Patterns
 
-Overflow reference for the `core-nfc` skill. Contains advanced patterns that exceed the main skill file's scope.
+Longer examples for the `core-nfc` skill. Each snippet assumes the session is
+already running and the tag is connected, as shown in the parent SKILL.md. Tag
+calls use their `async` forms from inside a `Task`, which avoids the Swift 6
+warnings about non-`Sendable` sessions and tags captured in `@Sendable`
+completion handlers. A delegate callback that starts such a `Task` passes the
+session and tag in as `nonisolated(unsafe)` copies; a plain capture fails the
+region-isolation check.
 
 ## Contents
 
-- [ISO 7816 APDU Commands](#iso-7816-apdu-commands)
-- [ISO 15693 Tag Reading](#iso-15693-tag-reading)
-- [MIFARE Tag Operations](#mifare-tag-operations)
-- [FeliCa Tag Operations](#felica-tag-operations)
-- [Multi-Record NDEF Messages](#multi-record-ndef-messages)
-- [NDEF Tag Locking](#ndef-tag-locking)
-- [SwiftUI NFC Scanner](#swiftui-nfc-scanner)
-- [Error Handling Reference](#error-handling-reference)
+- [Handling several tags at once](#handling-several-tags-at-once)
+- [ISO 7816 APDU commands](#iso-7816-apdu-commands)
+- [ISO 15693 tags](#iso-15693-tags)
+- [MIFARE tags](#mifare-tags)
+- [FeliCa tags](#felica-tags)
+- [Messages with several records](#messages-with-several-records)
+- [Locking a tag](#locking-a-tag)
+- [A SwiftUI scanner](#a-swiftui-scanner)
+- [Error codes](#error-codes)
 
-## ISO 7816 APDU Commands
+## Handling several tags at once
 
-Send APDU commands to ISO 7816-compliant smart cards and tags:
+`tagReaderSession(_:didDetect:)` and `readerSession(_:didDetect:)` hand over an
+array. More than one entry means several tags are in the field together, and
+commands sent to one of them may be answered by the wrong chip or not at all.
 
 ```swift
-import CoreNFC
+func tagReaderSession(_ reader: NFCTagReaderSession, didDetect found: [NFCTag]) {
+    nonisolated(unsafe) let reader = reader
+    if found.count > 1 {
+        reader.alertMessage = "Several tags are in range. Keep only one near the phone."
+        Task {
+            try? await Task.sleep(for: .milliseconds(500))
+            reader.restartPolling()
+        }
+        return
+    }
+    if !found.isEmpty {
+        nonisolated(unsafe) let tags = found
+        Task {
+            try? await reader.connect(to: tags[0])
+            // Continue with the single tag.
+        }
+    } else {
+        reader.restartPolling()
+    }
+}
+```
+
+The session stays alive while polling restarts, so the user does not see the
+sheet close and reopen. Scanning a series of tags one after another follows the
+same idea: after finishing with a tag, update `alertMessage` and call
+`restartPolling()` instead of invalidating.
+
+## ISO 7816 APDU commands
 
-func readISO7816(
-    tag: NFCISO7816Tag,
-    session: NFCTagReaderSession
-) {
-    // Select application by AID
-    let selectAID = NFCISO7816APDU(
+An APDU is built from class, instruction, two parameters, data and the expected
+response length. Selecting an application by its identifier:
+
+```swift
+func select(_ card: any NFCISO7816Tag, in session: NFCTagReaderSession) async {
+    let aid = Data([0xF0, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06])
+    let selectApp = NFCISO7816APDU(
         instructionClass: 0x00,
         instructionCode: 0xA4,
         p1Parameter: 0x04,
         p2Parameter: 0x00,
-        data: Data([0xD2, 0x76, 0x00, 0x00, 0x85, 0x01, 0x01]),
+        data: aid,
         expectedResponseLength: -1
     )
-
-    tag.sendCommand(apdu: selectAID) { data, sw1, sw2, error in
-        guard error == nil, sw1 == 0x90, sw2 == 0x00 else {
-            session.invalidate(errorMessage: "Select failed.")
+    do {
+        let (_, sw1, sw2) = try await card.sendCommand(apdu: selectApp)
+        guard (sw1, sw2) == (0x90, 0x00) else {
+            session.invalidate(errorMessage: "The card rejected the application.")
             return
         }
-
-        // Read binary
-        let readBinary = NFCISO7816APDU(
+        let readFile = NFCISO7816APDU(
             instructionClass: 0x00,
             instructionCode: 0xB0,
             p1Parameter: 0x00,
@@ -49,402 +84,271 @@ func readISO7816(
             data: Data(),
             expectedResponseLength: 256
         )
-
-        tag.sendCommand(apdu: readBinary) { data, sw1, sw2, error in
-            guard error == nil else {
-                session.invalidate(errorMessage: "Read failed.")
-                return
-            }
-            print("Read \(data.count) bytes, SW: \(sw1) \(sw2)")
-            session.alertMessage = "Tag read successfully."
-            session.invalidate()
-        }
+        let (body, status1, status2) = try await card.sendCommand(apdu: readFile)
+        let ok = status1 == 0x90 && status2 == 0x00
+        session.alertMessage = ok ? "Read \(body.count) bytes." : "Read failed."
+        session.invalidate()
+    } catch {
+        session.invalidate(errorMessage: "The card stopped answering.")
     }
 }
 ```
 
-### Common APDU Commands
+`90 00` is the success status word. An `expectedResponseLength` of `-1` lets the
+card decide how much to return. The AID used here must also appear in the
+Info.plist select-identifiers list.
 
-| Command | CLA | INS | Description |
-|---|---|---|---|
-| SELECT | 0x00 | 0xA4 | Select an application or file |
-| READ BINARY | 0x00 | 0xB0 | Read data from a transparent file |
-| UPDATE BINARY | 0x00 | 0xD6 | Write data to a transparent file |
-| READ RECORD | 0x00 | 0xB2 | Read a record from a record-oriented file |
-| GET DATA | 0x00 | 0xCA | Retrieve a data object |
+| Command | CLA | INS |
+|---------|-----|-----|
+| SELECT | 0x00 | 0xA4 |
+| READ BINARY | 0x00 | 0xB0 |
+| UPDATE BINARY | 0x00 | 0xD6 |
+| READ RECORD | 0x00 | 0xB2 |
+| GET DATA | 0x00 | 0xCA |
 
-## ISO 15693 Tag Reading
+A small helper used by the examples below:
 
 ```swift
-func readISO15693(
-    tag: NFCISO15693Tag,
-    session: NFCTagReaderSession
-) {
-    // Read a single block
-    tag.readSingleBlock(
-        requestFlags: [.highDataRate, .address],
-        blockNumber: 0
-    ) { data, error in
-        guard let data, error == nil else {
-            session.invalidate(errorMessage: "Read failed.")
-            return
-        }
-        print("Block 0: \(data.map { String(format: "%02x", $0) }.joined())")
-    }
-
-    // Read multiple blocks
-    tag.readMultipleBlocks(
-        requestFlags: [.highDataRate, .address],
-        blockRange: NSRange(location: 0, length: 4)
-    ) { blocks, error in
-        guard let blocks, error == nil else { return }
-        for (index, block) in blocks.enumerated() {
-            print("Block \(index): \(block.count) bytes")
-        }
-        session.alertMessage = "Read \(blocks.count) blocks."
-        session.invalidate()
-    }
+func hex(_ bytes: Data) -> String {
+    bytes.map { String(format: "%02X", $0) }.joined()
 }
 ```
 
-### Getting System Info
+## ISO 15693 tags
 
 ```swift
-tag.getSystemInfo(requestFlags: [.highDataRate, .address]) {
-    identifier, dsfid, afi, blockSize, blockCount, icReference, error in
-    guard error == nil else { return }
-    print("UID: \(identifier.map { String(format: "%02x", $0) }.joined())")
-    print("Block size: \(blockSize), Block count: \(blockCount)")
+func readBlocks(_ label: any NFCISO15693Tag, in session: NFCTagReaderSession) async {
+    do {
+        let info = try await label.systemInfo(requestFlags: [.highDataRate])
+        let uidHex = hex(info.uniqueIdentifier)
+        session.alertMessage = "Tag \(uidHex): \(info.totalBlocks) blocks of \(info.blockSize) bytes"
+
+        let first = try await label.readSingleBlock(
+            requestFlags: [.address, .highDataRate],
+            blockNumber: 0
+        )
+        let rest = try await label.readMultipleBlocks(
+            requestFlags: [.address, .highDataRate],
+            blockRange: NSRange(location: 1, length: 4)
+        )
+        session.alertMessage = "Read \(1 + rest.count) blocks, \(first.count) bytes in block 0."
+        session.invalidate()
+    } catch {
+        session.invalidate(errorMessage: "No system info.")
+    }
 }
 ```
 
-## MIFARE Tag Operations
+`systemInfo(requestFlags:)` returns an `NFCISO15693SystemInfo`: the
+identifier, DSFID, AFI, block size, total block count and IC reference, which
+tells you how far you can read. The callback form, `getSystemInfo`, hands the
+same value over in a `Result`.
+
+## MIFARE tags
 
 ```swift
-func readMiFare(
-    tag: NFCMiFareTag,
-    session: NFCTagReaderSession
-) {
-    // Identify MIFARE family
-    switch tag.mifareFamily {
+func inspect(_ chip: any NFCMiFareTag, in session: NFCTagReaderSession) async {
+    switch chip.mifareFamily {
     case .ultralight:
-        readMiFareUltralight(tag: tag, session: session)
-    case .desfire:
-        session.invalidate(
-            errorMessage: "Use app-specific DESFire commands for this card."
-        )
-    case .plus:
-        print("MIFARE Plus tag detected")
-        session.invalidate()
-    case .unknown:
-        print("Unknown MIFARE tag")
+        let pages = try? await chip.sendMiFareCommand(commandPacket: Data([0x30, 0x04]))
+        session.alertMessage = pages == nil ? "Read failed." : "Pages 4 to 7 read."
         session.invalidate()
+    case .desfire:
+        // DESFire needs the application-specific command set of your card issuer.
+        session.invalidate(errorMessage: "DESFire cards need a dedicated command set.")
+    case .plus, .unknown:
+        session.invalidate(errorMessage: "This MIFARE type is not handled.")
     @unknown default:
-        session.invalidate()
-    }
-}
-
-func readMiFareUltralight(
-    tag: NFCMiFareTag,
-    session: NFCTagReaderSession
-) {
-    // READ command: reads 4 pages starting at page 4
-    let readCommand = Data([0x30, 0x04])
-
-    tag.sendMiFareCommand(commandPacket: readCommand) { data, error in
-        guard error == nil else {
-            session.invalidate(errorMessage: "Read failed.")
-            return
-        }
-        print("Read \(data.count) bytes from MIFARE Ultralight")
-        session.alertMessage = "Tag read successfully."
-        session.invalidate()
+        session.invalidate(errorMessage: "Unrecognised MIFARE family.")
     }
 }
 ```
 
-## FeliCa Tag Operations
+The Ultralight READ command `0x30` with page `0x04` returns four pages
+starting at page 4.
 
-FeliCa discovery requires `.iso18092` polling and
-`com.apple.developer.nfc.readersession.felica.systemcodes` entries in
-Info.plist. Each system code must be explicit; wildcard values are not allowed.
+## FeliCa tags
 
-```swift
-func readFeliCa(
-    tag: NFCFeliCaTag,
-    session: NFCTagReaderSession
-) {
-    tag.requestSystemCode { systemCodes, error in
-        guard error == nil else {
-            session.invalidate(errorMessage: "System code request failed.")
-            return
-        }
+FeliCa cards are only found when the session polls `.iso18092` and the
+Info.plist lists the exact system codes; wildcards are rejected.
 
-        let codes = systemCodes.map {
-            $0.map { String(format: "%02x", $0) }.joined()
-        }
-        print("FeliCa system codes: \(codes.joined(separator: ", "))")
-        session.alertMessage = "FeliCa tag read successfully."
-        session.invalidate()
-    }
+```swift
+func readSystemCodes(_ card: any NFCFeliCaTag, in session: NFCTagReaderSession) async {
+    let codes = (try? await card.requestSystemCode()) ?? []
+    session.alertMessage = "System codes: \(codes.map(hex).joined(separator: ", "))"
+    session.invalidate()
 }
 ```
 
-## Multi-Record NDEF Messages
+## Messages with several records
 
-Build messages with multiple records of different types:
+One NDEF message can mix record kinds, for example a label, a link and an app
+payload:
 
 ```swift
-func buildMultiRecordMessage() -> NFCNDEFMessage {
-    var records: [NFCNDEFPayload] = []
-
-    // Text record
-    if let textPayload = NFCNDEFPayload.wellKnownTypeTextPayload(
-        string: "Product: Widget Pro",
-        locale: Locale(identifier: "en")
-    ) {
-        records.append(textPayload)
-    }
-
-    // URL record
-    if let urlPayload = NFCNDEFPayload.wellKnownTypeURIPayload(
-        url: URL(string: "https://example.com/product/123")!
-    ) {
-        records.append(urlPayload)
-    }
-
-    // Custom external type record
-    let externalPayload = NFCNDEFPayload(
+func shelfMessage(for id: String) -> NFCNDEFMessage? {
+    guard
+        let label = NFCNDEFPayload.wellKnownTypeTextPayload(string: "Shelf \(id)", locale: Locale(identifier: "en")),
+        let address = URL(string: "https://example.com/shelf/" + id),
+        let link = NFCNDEFPayload.wellKnownTypeURIPayload(url: address)
+    else { return nil }
+    let data = NFCNDEFPayload(
         format: .nfcExternal,
-        type: "com.example:product".data(using: .utf8)!,
+        type: Data("example.com:shelf".utf8),
         identifier: Data(),
-        payload: """
-        {"sku":"WP-001","batch":"2026-03"}
-        """.data(using: .utf8)!
+        payload: Data(#"{"id":"\#(id)"}"#.utf8)
     )
-    records.append(externalPayload)
-
-    return NFCNDEFMessage(records: records)
+    return NFCNDEFMessage(records: [label, link, data])
 }
 ```
 
-### Checking Message Size Against Tag Capacity
-
-```swift
-func writeIfFits(
-    message: NFCNDEFMessage,
-    to tag: any NFCNDEFTag,
-    session: NFCNDEFReaderSession
-) {
-    tag.queryNDEFStatus { status, capacity, error in
-        guard status == .readWrite else {
-            session.invalidate(errorMessage: "Tag is not writable.")
-            return
-        }
+### Checking capacity
 
-        let messageLength = message.length
-        guard messageLength <= capacity else {
-            session.invalidate(
-                errorMessage: "Message (\(messageLength) bytes) exceeds "
-                + "tag capacity (\(capacity) bytes)."
-            )
-            return
-        }
+`queryNDEFStatus` returns the capacity in bytes. Compare it with the message
+length before writing:
 
-        tag.writeNDEF(message) { error in
-            if let error {
-                session.invalidate(
-                    errorMessage: "Write failed: \(error.localizedDescription)"
-                )
-            } else {
-                session.alertMessage = "Written \(messageLength) bytes."
-                session.invalidate()
-            }
-        }
-    }
+```swift
+let (status, capacity) = try await tag.queryNDEFStatus()
+guard status == .readWrite else {
+    session.invalidate(errorMessage: "Writes are blocked on this tag.")
+    return
+}
+guard message.length <= capacity else {
+    session.invalidate(errorMessage: "Data needs \(message.length) bytes; the tag holds \(capacity).")
+    return
 }
+try await tag.writeNDEF(message)
+session.invalidate()
 ```
 
-## NDEF Tag Locking
+## Locking a tag
 
-Lock a tag to make it permanently read-only. This is irreversible.
+`writeLock` turns a tag read-only for good. There is no undo, so confirm the
+status is `.readWrite`, and confirm with the user, before calling it.
 
 ```swift
-func lockTag(
-    _ tag: any NFCNDEFTag,
-    session: NFCNDEFReaderSession
-) {
-    tag.queryNDEFStatus { status, _, error in
-        guard status == .readWrite else {
-            session.invalidate(errorMessage: "Tag is already read-only.")
-            return
-        }
-
-        tag.writeLock { error in
-            if let error {
-                session.invalidate(
-                    errorMessage: "Lock failed: \(error.localizedDescription)"
-                )
-            } else {
-                session.alertMessage = "Tag locked permanently."
-                session.invalidate()
-            }
-        }
-    }
+do {
+    try await tag.writeLock()
+    session.alertMessage = "Tag locked."
+    session.invalidate()
+} catch {
+    session.invalidate(errorMessage: "Could not lock: \(error.localizedDescription)")
 }
 ```
 
-## SwiftUI NFC Scanner
-
-Wrap the NFC reader in an `@Observable` model for SwiftUI integration:
+## A SwiftUI scanner
 
 ```swift
 import CoreNFC
 import SwiftUI
 
-@Observable
-@MainActor
-final class NFCScannerModel: NSObject {
-    var scannedText: String = ""
-    var scannedURL: URL?
+@Observable @MainActor
+final class StickerScanner: NSObject {
+    var lastText: String?
+    var lastLink: URL?
     var isScanning = false
-    var errorMessage: String?
+    var failure: String?
+    let isAvailable = NFCNDEFReaderSession.readingAvailable
 
     private var session: NFCNDEFReaderSession?
 
-    var isAvailable: Bool {
-        NFCNDEFReaderSession.readingAvailable
-    }
-
-    func startScan() {
-        guard isAvailable else {
-            errorMessage = "NFC not available on this device."
-            return
-        }
-
+    func start() {
+        guard isAvailable else { return }
         session = NFCNDEFReaderSession(
             delegate: self,
             queue: nil,
             invalidateAfterFirstRead: true
         )
-        session?.alertMessage = "Hold your iPhone near an NFC tag."
+        session?.alertMessage = "Hold the sticker near your iPhone."
         session?.begin()
         isScanning = true
-        errorMessage = nil
     }
 }
 
-extension NFCScannerModel: NFCNDEFReaderSessionDelegate {
-    nonisolated func readerSessionDidBecomeActive(
-        _ session: NFCNDEFReaderSession
-    ) { }
+extension StickerScanner: NFCNDEFReaderSessionDelegate {
+    nonisolated func readerSessionDidBecomeActive(_ reader: NFCNDEFReaderSession) {}
 
-    nonisolated func readerSession(
-        _ session: NFCNDEFReaderSession,
-        didDetectNDEFs messages: [NFCNDEFMessage]
-    ) {
+    nonisolated func readerSession(_ reader: NFCNDEFReaderSession, didDetectNDEFs found: [NFCNDEFMessage]) {
+        let record = found.first?.records.first
+        let link = record?.wellKnownTypeURIPayload()
+        let text = record?.wellKnownTypeTextPayload().0
         Task { @MainActor in
-            for message in messages {
-                for record in message.records {
-                    if let url = record.wellKnownTypeURIPayload() {
-                        scannedURL = url
-                    }
-                    if let (text, _) = record.wellKnownTypeTextPayload() {
-                        scannedText = text
-                    }
-                }
-            }
-            isScanning = false
+            self.lastLink = link
+            self.lastText = text
         }
     }
 
-    nonisolated func readerSession(
-        _ session: NFCNDEFReaderSession,
-        didInvalidateWithError error: Error
-    ) {
+    nonisolated func readerSession(_ reader: NFCNDEFReaderSession, didInvalidateWithError error: any Error) {
+        let code = (error as? NFCReaderError)?.code
+        let quiet = code == .readerSessionInvalidationErrorUserCanceled
+            || code == .readerSessionInvalidationErrorFirstNDEFTagRead
+        let message = quiet ? nil : error.localizedDescription
         Task { @MainActor in
-            let nfcError = error as? NFCReaderError
-            if nfcError?.code != .readerSessionInvalidationErrorUserCanceled,
-               nfcError?.code != .readerSessionInvalidationErrorFirstNDEFTagRead {
-                errorMessage = error.localizedDescription
-            }
-            isScanning = false
+            self.failure = message
+            self.isScanning = false
             self.session = nil
         }
     }
 }
 
-struct NFCScannerView: View {
-    @State private var scanner = NFCScannerModel()
+struct StickerScanView: View {
+    @State private var scanner = StickerScanner()
 
     var body: some View {
-        VStack {
-            if !scanner.isAvailable {
-                ContentUnavailableView(
-                    "NFC Unavailable",
-                    systemImage: "wave.3.right.circle.fill",
-                    description: Text("This device does not support NFC.")
-                )
-            } else {
-                Button("Scan NFC Tag") {
-                    scanner.startScan()
-                }
-                .buttonStyle(.borderedProminent)
-                .disabled(scanner.isScanning)
-
-                if let url = scanner.scannedURL {
-                    Text("URL: \(url.absoluteString)")
-                }
-                if !scanner.scannedText.isEmpty {
-                    Text("Text: \(scanner.scannedText)")
-                }
-                if let error = scanner.errorMessage {
-                    Text(error).foregroundStyle(.red)
-                }
+        if scanner.isAvailable {
+            VStack(spacing: 12) {
+                Button("Scan Sticker") { scanner.start() }
+                    .buttonStyle(.borderedProminent)
+                    .disabled(scanner.isScanning)
+                if let link = scanner.lastLink { Link(link.absoluteString, destination: link) }
+                if let text = scanner.lastText { Text(text) }
+                if let failure = scanner.failure { Text(failure).foregroundStyle(.red) }
             }
+        } else {
+            ContentUnavailableView(
+                "NFC Unavailable",
+                systemImage: "wave.3.right.circle.fill",
+                description: Text("This device cannot read NFC tags.")
+            )
         }
-        .padding()
     }
 }
 ```
 
-## Error Handling Reference
+The delegate callbacks arrive off the main actor, so they are `nonisolated`
+and hop back with `Task { @MainActor in }` before touching state. Only plain
+values cross that hop.
 
-### NFCReaderError Codes
+## Error codes
 
-| Code | Meaning |
-|---|---|
-| `.readerSessionInvalidationErrorUserCanceled` | User tapped Cancel in the NFC sheet |
-| `.readerSessionInvalidationErrorFirstNDEFTagRead` | Session ended after first read (when `invalidateAfterFirstRead` is true) |
-| `.readerSessionInvalidationErrorSessionTimeout` | 60-second session timeout elapsed |
-| `.readerSessionInvalidationErrorSessionTerminatedUnexpectedly` | System terminated the session |
-| `.readerTransceiveErrorTagConnectionLost` | Tag moved out of range during communication |
-| `.readerTransceiveErrorRetryExceeded` | Too many failed communication attempts |
-| `.readerTransceiveErrorTagNotConnected` | Attempted to communicate without connecting first |
-| `.readerSessionInvalidationErrorSystemIsBusy` | Another NFC session is active |
+| `NFCReaderError.Code` | Meaning |
+|-----------------------|---------|
+| `.readerSessionInvalidationErrorUserCanceled` | User pressed Cancel |
+| `.readerSessionInvalidationErrorFirstNDEFTagRead` | Session ended after one read because `invalidateAfterFirstRead` was true |
+| `.readerSessionInvalidationErrorSessionTimeout` | The 60-second session limit ran out |
+| `.readerSessionInvalidationErrorSessionTerminatedUnexpectedly` | The system ended the session |
+| `.readerSessionInvalidationErrorSystemIsBusy` | Another NFC session is already running |
+| `.readerTransceiveErrorTagConnectionLost` | The tag left the field mid-exchange |
+| `.readerTransceiveErrorRetryExceeded` | Too many failed attempts |
+| `.readerTransceiveErrorTagNotConnected` | A command was sent before connecting |
 
-### Graceful Error Recovery
+A recovery helper that turns codes into user text:
 
 ```swift
-nonisolated func readerSession(
-    _ session: NFCNDEFReaderSession,
-    didInvalidateWithError error: Error
-) {
-    let nfcError = error as? NFCReaderError
-    Task { @MainActor in
-        switch nfcError?.code {
-        case .readerSessionInvalidationErrorUserCanceled:
-            break  // User chose to cancel
-        case .readerSessionInvalidationErrorFirstNDEFTagRead:
-            break  // Expected when invalidateAfterFirstRead is true
-        case .readerSessionInvalidationErrorSessionTimeout:
-            errorMessage = "Scan timed out. Try again."
-        case .readerTransceiveErrorTagConnectionLost:
-            errorMessage = "Tag moved away. Hold steady and try again."
-        default:
-            errorMessage = error.localizedDescription
-        }
-        self.session = nil
+func userMessage(for error: Error) -> String? {
+    guard let code = (error as? NFCReaderError)?.code else { return error.localizedDescription }
+    switch code {
+    case .readerSessionInvalidationErrorUserCanceled,
+         .readerSessionInvalidationErrorFirstNDEFTagRead:
+        return nil
+    case .readerSessionInvalidationErrorSessionTimeout:
+        return "Scanning took too long. Try again."
+    case .readerTransceiveErrorTagConnectionLost:
+        return "Keep the tag still until the scan finishes."
+    default:
+        return error.localizedDescription
     }
 }
 ```
+
+Whatever the message, clear the stored session in the same callback.