@delicity/capacitor-thermal-printer 7.0.0

package/ios/Plugin/Adapters/StarAdapter.swift

@@ -0,0 +1,305 @@
+import Foundation
+import UIKit
+
+#if canImport(StarIO10)
+import StarIO10
+#endif
+
+/// Adapter Star iOS basé sur StarXpand SDK (StarIO10).
+///
+/// ⭐ Star est le mieux supporté sur iOS (MFi) et le seul fabricant auto-installable :
+/// via Swift Package Manager (`https://github.com/star-micronics/StarXpand-SDK-iOS`).
+/// On utilise la compilation conditionnelle `#if canImport(StarIO10)` :
+///   - si l'app a ajouté le package StarXpand -> code TYPÉ compilé et actif,
+///   - sinon -> stub inerte, `isAvailable()` renvoie false, l'adapter est ignoré.
+///
+/// INSTALLATION : voir docs/SDK_INTEGRATION.md (§ Star iOS).
+final class StarAdapter: PrinterAdapter {
+
+    let id: AdapterId = .star
+
+    /// Connexions ouvertes indexées par printerId (StarPrinter est une classe -> AnyObject).
+    private var connections: [String: AnyObject] = [:]
+    private let lock = NSLock()
+
+    #if canImport(StarIO10)
+    /// Délégué de découverte retenu le temps du scan.
+    private var discoveryDelegate: StarDiscoveryDelegate?
+    private var discoveryManager: StarDeviceDiscoveryManager?
+    #endif
+
+    func isAvailable() -> Bool {
+        #if canImport(StarIO10)
+        return true
+        #else
+        return false
+        #endif
+    }
+
+    func canHandle(_ profile: PrinterProfile) -> Bool { isAvailable() && profile.adapter == .star }
+
+    func supportsTextItems() -> Bool { isAvailable() }
+
+    // MARK: Découverte
+
+    func discover(timeoutMs: Int, onFound: @escaping (DiscoveredPrinter) -> Void) async {
+        #if canImport(StarIO10)
+        guard let manager = try? StarDeviceDiscoveryManagerFactory.create(
+            interfaceTypes: [.lan, .bluetooth, .bluetoothLE, .usb]
+        ) else { return }
+        manager.discoveryTime = min(max(timeoutMs, 1000), 30000)
+
+        await withCheckedContinuation { (cont: CheckedContinuation<Void, Never>) in
+            let delegate = StarDiscoveryDelegate(
+                onFound: { printer in
+                    let settings = printer.connectionSettings
+                    let transport = Self.transport(for: settings.interfaceType)
+                    let model = printer.information?.model.map { String(describing: $0) }
+                    onFound(DiscoveredPrinter(
+                        id: "star:\(settings.interfaceType):\(settings.identifier)",
+                        name: model ?? "Star Printer",
+                        brand: "Star",
+                        model: model,
+                        transport: transport,
+                        adapter: .star,
+                        address: settings.identifier,
+                        discoveredBy: ["star"]
+                    ))
+                },
+                onFinish: { [weak self] in
+                    self?.lock.lock(); let resumed = self?.discoveryDelegate != nil; self?.discoveryDelegate = nil; self?.lock.unlock()
+                    if resumed { cont.resume() }
+                }
+            )
+            self.lock.lock(); self.discoveryDelegate = delegate; self.discoveryManager = manager; self.lock.unlock()
+            manager.delegate = delegate
+            do { try manager.startDiscovery() } catch {
+                self.lock.lock(); self.discoveryDelegate = nil; self.lock.unlock()
+                cont.resume()
+            }
+        }
+        manager.stopDiscovery()
+        #endif
+    }
+
+    // MARK: Connexion
+
+    func connect(_ profile: PrinterProfile, timeoutMs: Int) async throws {
+        #if canImport(StarIO10)
+        if isConnected(profile.id) { return }
+        let printer = StarPrinter(Self.connectionSettings(for: profile))
+        do {
+            try await printer.open()
+        } catch {
+            throw PrinterError(.CONNECTION_FAILED, "Connexion Star échouée: \(profile.address)", detail: "\(error)", retryable: true)
+        }
+        lock.lock(); connections[profile.id] = printer; lock.unlock()
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Star (StarIO10) absent")
+        #endif
+    }
+
+    func isConnected(_ printerId: String) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        return connections[printerId] != nil
+    }
+
+    func disconnect(_ printerId: String) async {
+        #if canImport(StarIO10)
+        lock.lock(); let p = connections.removeValue(forKey: printerId) as? StarPrinter; lock.unlock()
+        if let p = p { try? await p.close() }
+        #endif
+    }
+
+    // MARK: Impression
+
+    func printImage(_ profile: PrinterProfile, image: UIImage, options: RenderOptions) async throws -> Int {
+        #if canImport(StarIO10)
+        let printer = try requireConnected(profile)
+        let printerBuilder = StarXpandCommand.PrinterBuilder()
+            .styleAlignment(Self.alignment(for: options.align))
+            .actionPrintImage(StarXpandCommand.Printer.ImageParameter(image: image, width: max(8, profile.capabilities.printableDots)))
+        if options.feedLines > 0 { _ = printerBuilder.actionFeedLine(options.feedLines) }
+        if options.cut && profile.capabilities.supportsCut { _ = printerBuilder.actionCut(.partial) }
+
+        let document = StarXpandCommand.DocumentBuilder().addPrinter(printerBuilder)
+        if options.openCashDrawer && profile.capabilities.supportsCashDrawer {
+            _ = document.addDrawer(StarXpandCommand.DrawerBuilder().actionOpen(StarXpandCommand.Drawer.OpenParameter()))
+        }
+        let commands = StarXpandCommand.StarXpandCommandBuilder().addDocument(document).getCommands()
+
+        var sent = 0
+        for _ in 0..<max(1, options.copies) {
+            try await send(printer, commands)
+            sent += commands.count
+        }
+        return sent
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Star (StarIO10) absent")
+        #endif
+    }
+
+    func printItems(_ profile: PrinterProfile, items: [PrintItem], defaultCodePage: String, cut: Bool, feedLines: Int) async throws -> Int {
+        #if canImport(StarIO10)
+        let printer = try requireConnected(profile)
+        let pb = StarXpandCommand.PrinterBuilder()
+        for item in items { Self.map(item, into: pb, profile: profile) }
+        if feedLines > 0 { _ = pb.actionFeedLine(feedLines) }
+        if cut && profile.capabilities.supportsCut { _ = pb.actionCut(.partial) }
+        let commands = StarXpandCommand.StarXpandCommandBuilder()
+            .addDocument(StarXpandCommand.DocumentBuilder().addPrinter(pb))
+            .getCommands()
+        try await send(printer, commands)
+        return commands.count
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Star (StarIO10) absent")
+        #endif
+    }
+
+    // MARK: Statut
+
+    func getStatus(_ profile: PrinterProfile) async throws -> PrinterStatus {
+        #if canImport(StarIO10)
+        lock.lock(); let p = connections[profile.id] as? StarPrinter; lock.unlock()
+        guard let printer = p else {
+            return PrinterStatus(id: profile.id, connection: "disconnected", online: false, paper: "unknown")
+        }
+        do {
+            let st = try await printer.getStatus()
+            let paperEmpty = st.paperEmpty
+            let coverOpen = st.coverOpen
+            return PrinterStatus(
+                id: profile.id, connection: "connected", online: !paperEmpty && !coverOpen,
+                paper: paperEmpty ? "empty" : (st.paperNearEmpty ? "near_end" : "ok"),
+                coverOpen: coverOpen,
+                errorCode: paperEmpty ? .PAPER_EMPTY : (coverOpen ? .COVER_OPEN : nil),
+                rawStatus: "\(st)"
+            )
+        } catch {
+            return PrinterStatus(id: profile.id, connection: "error", online: false, paper: "unknown", rawStatus: "\(error)")
+        }
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Star (StarIO10) absent")
+        #endif
+    }
+
+    // MARK: Helpers (typés, sous canImport)
+
+    #if canImport(StarIO10)
+    private func requireConnected(_ profile: PrinterProfile) throws -> StarPrinter {
+        lock.lock(); let p = connections[profile.id] as? StarPrinter; lock.unlock()
+        guard let printer = p else { throw PrinterError(.CONNECTION_FAILED, "Star non connecté: \(profile.id)") }
+        return printer
+    }
+
+    private func send(_ printer: StarPrinter, _ commands: String) async throws {
+        do { try await printer.print(command: commands) }
+        catch { throw PrinterError(.PRINT_FAILED, "Impression Star échouée", detail: "\(error)", retryable: true) }
+    }
+
+    private static func connectionSettings(for profile: PrinterProfile) -> StarConnectionSettings {
+        let iface: InterfaceType
+        switch profile.transport {
+        case .wifi, .ethernet: iface = .lan
+        case .bluetooth: iface = .bluetooth
+        case .ble: iface = .bluetoothLE
+        case .usb: iface = .usb
+        }
+        let identifier = iface == .lan ? String(profile.address.split(separator: ":").first ?? "") : profile.address
+        return StarConnectionSettings(interfaceType: iface, identifier: identifier)
+    }
+
+    private static func transport(for iface: InterfaceType) -> Transport {
+        switch iface {
+        case .lan: return .wifi
+        case .bluetooth: return .bluetooth
+        case .bluetoothLE: return .ble
+        case .usb: return .usb
+        @unknown default: return .wifi
+        }
+    }
+
+    private static func alignment(for align: String) -> StarXpandCommand.Printer.Alignment {
+        switch align {
+        case "center": return .center
+        case "right": return .right
+        default: return .left
+        }
+    }
+
+    /// Mappe un PrintItem vers le PrinterBuilder StarXpand (best effort par type).
+    private static func map(_ item: PrintItem, into pb: StarXpandCommand.PrinterBuilder, profile: PrinterProfile) {
+        switch item {
+        case let .text(value, style):
+            if let a = style.align { _ = pb.styleAlignment(alignment(for: a)) }
+            _ = pb.styleBold(style.bold)
+            _ = pb.styleInvert(style.invert)
+            _ = pb.styleUnderLine(style.underline != "none")
+            _ = pb.styleMagnification(StarXpandCommand.MagnificationParameter(
+                width: min(max(style.widthMultiplier, 1), 6), height: min(max(style.heightMultiplier, 1), 6)))
+            _ = pb.actionPrintText(style.newline ? value + "\n" : value)
+            _ = pb.styleBold(false).styleInvert(false).styleUnderLine(false)
+                .styleMagnification(StarXpandCommand.MagnificationParameter(width: 1, height: 1))
+        case let .feed(lines):
+            _ = pb.actionFeedLine(max(1, lines))
+        case let .cut(mode, _):
+            _ = pb.actionCut(mode == "full" ? .full : .partial)
+        case let .divider(char, columns, align, bold):
+            let cols = columns ?? (profile.capabilities.printableDots <= 420 ? 32 : 48)
+            if let a = align { _ = pb.styleAlignment(alignment(for: a)) }
+            _ = pb.styleBold(bold)
+            _ = pb.actionPrintText(String(repeating: char, count: min(max(cols, 1), 96)) + "\n")
+            _ = pb.styleBold(false)
+        case let .qrcode(value, size, ec, align):
+            _ = pb.styleAlignment(alignment(for: align))
+            _ = pb.actionPrintQRCode(StarXpandCommand.Printer.QRCodeParameter(content: value)
+                .setLevel(qrLevel(for: ec))
+                .setCellSize(min(max(size, 1), 16)))
+        case let .barcode(value, symbology, height, _, hri, align):
+            _ = pb.styleAlignment(alignment(for: align))
+            _ = pb.actionPrintBarcode(StarXpandCommand.Printer.BarcodeParameter(content: value, symbology: barcodeSymbology(for: symbology))
+                .setHeight(Double(min(max(height, 1), 255)))
+                .setPrintHri(hri != "none"))
+        case .cashDrawer, .image, .raw:
+            // tiroir -> openCashDrawer ; image -> printImage ; raw -> non supporté par StarXpand.
+            break
+        }
+    }
+
+    private static func qrLevel(for ec: String) -> StarXpandCommand.Printer.QRCodeLevel {
+        switch ec.uppercased() {
+        case "L": return .l
+        case "Q": return .q
+        case "H": return .h
+        default: return .m
+        }
+    }
+
+    private static func barcodeSymbology(for s: String) -> StarXpandCommand.Printer.BarcodeSymbology {
+        switch s.uppercased() {
+        case "CODE39": return .code39
+        case "CODE93": return .code93
+        case "EAN13", "JAN13": return .jan13
+        case "EAN8", "JAN8": return .jan8
+        case "ITF": return .itf
+        case "UPCA": return .upcA
+        case "UPCE": return .upcE
+        case "NW7", "CODABAR": return .nw7
+        default: return .code128
+        }
+    }
+    #endif
+}
+
+#if canImport(StarIO10)
+/// Délégué de découverte StarXpand (retenu par l'adapter le temps du scan).
+private final class StarDiscoveryDelegate: NSObject, StarDeviceDiscoveryManagerDelegate {
+    private let onFound: (StarPrinter) -> Void
+    private let onFinish: () -> Void
+    init(onFound: @escaping (StarPrinter) -> Void, onFinish: @escaping () -> Void) {
+        self.onFound = onFound; self.onFinish = onFinish
+    }
+    func manager(_ manager: StarDeviceDiscoveryManager, didFind printer: StarPrinter) { onFound(printer) }
+    func managerDidFinishDiscovery(_ manager: StarDeviceDiscoveryManager) { onFinish() }
+}
+#endif

package/ios/Plugin/Adapters/ZebraAdapter.swift

@@ -0,0 +1,119 @@
+import Foundation
+import UIKit
+
+// Le SDK Link-OS iOS est livré en xcframework manuel (licence Zebra, non
+// redistribuable, pas de pod/SPM officiel). Nom de module possible `ZSDK_API`.
+// Import absent -> stub inerte. Voir docs/SDK_INTEGRATION.md (§ Zebra iOS).
+#if canImport(ZSDK_API)
+import ZSDK_API
+#endif
+
+/// Adapter Zebra iOS (Link-OS SDK / ZSDK).
+///
+/// ⚠️ Comme sur Android : Zebra = ZPL/CPCL, JAMAIS ESC/POS. Le SDK convertit un
+/// CGImage en ZPL et l'imprime via GraphicsUtil. Transports : TCP + Bluetooth MFi.
+/// API ObjC à VÉRIFIER sur device avec le xcframework réel.
+final class ZebraAdapter: PrinterAdapter {
+
+    let id: AdapterId = .zebra
+    private var connections: [String: AnyObject] = [:]
+    private let lock = NSLock()
+
+    func isAvailable() -> Bool {
+        #if canImport(ZSDK_API)
+        return true
+        #else
+        return NSClassFromString("TcpPrinterConnection") != nil || NSClassFromString("ZebraPrinterFactory") != nil
+        #endif
+    }
+
+    func canHandle(_ profile: PrinterProfile) -> Bool { isAvailable() && profile.adapter == .zebra }
+
+    func discover(timeoutMs: Int, onFound: @escaping (DiscoveredPrinter) -> Void) async {
+        // NetworkDiscoverer.localBroadcast(...) disponible mais bloquant/ObjC ;
+        // les Zebra réseau restent trouvées par le scan TCP générique.
+    }
+
+    func connect(_ profile: PrinterProfile, timeoutMs: Int) async throws {
+        #if canImport(ZSDK_API)
+        if isConnected(profile.id) { return }
+        let (host, port) = Self.hostPort(profile.address)
+        guard let conn = TcpPrinterConnection(address: host, andWithPort: port) else {
+            throw PrinterError(.CONNECTION_FAILED, "Init connexion Zebra échouée")
+        }
+        conn.setMaxTimeoutForRead(Int32(timeoutMs))
+        if !conn.open() {
+            throw PrinterError(.CONNECTION_FAILED, "Connexion Zebra échouée: \(profile.address)", retryable: true)
+        }
+        lock.lock(); connections[profile.id] = conn; lock.unlock()
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Zebra Link-OS absent")
+        #endif
+    }
+
+    func isConnected(_ printerId: String) -> Bool {
+        lock.lock(); defer { lock.unlock() }
+        return connections[printerId] != nil
+    }
+
+    func disconnect(_ printerId: String) async {
+        #if canImport(ZSDK_API)
+        lock.lock(); let c = connections.removeValue(forKey: printerId) as? ZebraPrinterConnection; lock.unlock()
+        c?.close()
+        #endif
+    }
+
+    func printImage(_ profile: PrinterProfile, image: UIImage, options: RenderOptions) async throws -> Int {
+        #if canImport(ZSDK_API)
+        lock.lock(); let c = connections[profile.id] as? ZebraPrinterConnection; lock.unlock()
+        guard let conn = c else { throw PrinterError(.CONNECTION_FAILED, "Zebra non connecté: \(profile.id)") }
+        guard let cg = image.cgImage else { throw PrinterError(.IMAGE_INVALID, "CGImage indisponible") }
+        do {
+            let printer = try ZebraPrinterFactory.getInstance(conn)
+            let tools = printer.getGraphicsUtil()
+            for _ in 0..<max(1, options.copies) {
+                try tools?.print(cg, atX: 0, atY: 0, withWidth: cg.width, withHeight: cg.height, andIsInsideFormat: false)
+            }
+        } catch {
+            throw PrinterError(.PRINT_FAILED, "Impression Zebra échouée", detail: "\(error)", retryable: true)
+        }
+        return cg.width * cg.height / 8
+        #else
+        throw PrinterError(.SDK_NOT_AVAILABLE, "SDK Zebra Link-OS absent")
+        #endif
+    }
+
+    func getStatus(_ profile: PrinterProfile) async throws -> PrinterStatus {
+        #if canImport(ZSDK_API)
+        lock.lock(); let c = connections[profile.id] as? ZebraPrinterConnection; lock.unlock()
+        guard let conn = c else {
+            return PrinterStatus(id: profile.id, connection: "disconnected", online: false, paper: "unknown")
+        }
+        do {
+            let printer = try ZebraPrinterFactory.getInstance(conn)
+            let st = try printer.getCurrentStatus()
+            let paperOut = st.isPaperOut
+            let headOpen = st.isHeadOpen
+            return PrinterStatus(
+                id: profile.id, connection: "connected", online: st.isReadyToPrint,
+                paper: paperOut ? "empty" : "ok", coverOpen: headOpen,
+                errorCode: paperOut ? .PAPER_EMPTY : (headOpen ? .COVER_OPEN : nil)
+            )
+        } catch {
+            return PrinterStatus(id: profile.id, connection: "error", online: false, paper: "unknown", rawStatus: "\(error)")
+        }
+        #else
+        return PrinterStatus(id: profile.id, connection: isConnected(profile.id) ? "connected" : "disconnected",
+                             online: isConnected(profile.id), paper: "unknown")
+        #endif
+    }
+
+    // MARK: Helpers
+
+    private static func hostPort(_ address: String) -> (String, Int) {
+        let parts = address.split(separator: ":")
+        let host = parts.first.map(String.init) ?? address
+        let port = parts.count > 1 ? (Int(parts[1]) ?? 9100) : 9100
+        return (host, port)
+    }
+}

package/ios/Plugin/Discovery/AdapterPriority.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+/// Moteur de priorité d'adapter (miroir iOS de priority.ts / AdapterPriority.kt).
+enum AdapterPriority {
+    static func score(_ p: DiscoveredPrinter) -> Int {
+        let brand = (p.brand ?? "").lowercased()
+        let isZebra = brand.contains("zebra") || p.adapter == .zebra
+        if isZebra { return p.adapter == .zebra ? 1000 : -1000 }
+
+        if p.adapter == .epson { return 900 }
+        if p.adapter == .star { return 890 }
+        if p.adapter == .brother { return 880 }
+
+        if p.adapter == .escpos {
+            return p.transport == .bluetooth ? 620 : 600
+        }
+        if p.transport == .ble { return 500 }
+        if p.adapter == .rawTcp { return 300 }
+        return 100
+    }
+}

package/ios/Plugin/Discovery/BonjourScanner.swift

@@ -0,0 +1,51 @@
+import Foundation
+import Network
+
+/// Découverte réseau iOS.
+///
+/// Recommandé : Bonjour/mDNS via NWBrowser pour `_pdl-datastream._tcp` (port 9100)
+/// et `_printer._tcp` / `_ipp._tcp`. C'est la méthode propre sur iOS (pas de scan
+/// d'IP brute, qui est mal vu et lent). Les imprimantes réseau modernes publient
+/// ces services.
+///
+/// ⚠️ Info.plist : nécessite NSLocalNetworkUsageDescription + NSBonjourServices
+/// listant les services recherchés.
+final class BonjourScanner {
+
+    private var browsers: [NWBrowser] = []
+
+    func scan(timeoutMs: Int, onFound: @escaping (DiscoveredPrinter) -> Void) async {
+        let services = ["_pdl-datastream._tcp", "_printer._tcp", "_ipp._tcp"]
+        let queue = DispatchQueue(label: "thermalprinter.bonjour")
+
+        for service in services {
+            let params = NWParameters()
+            params.includePeerToPeer = false
+            let browser = NWBrowser(for: .bonjour(type: service, domain: nil), using: params)
+            browser.browseResultsChangedHandler = { results, _ in
+                for result in results {
+                    if case let .service(name, _, _, _) = result.endpoint {
+                        // La résolution IP se fait à la connexion via NWConnection(endpoint:).
+                        let printer = DiscoveredPrinter(
+                            id: "wifi:\(name)",
+                            name: name,
+                            brand: nil, model: nil,
+                            transport: .wifi,
+                            adapter: .escpos,           // arbitré ensuite par la priorité
+                            address: "\(name)._\(service)",  // résolu via NWEndpoint à la connexion
+                            capabilities: Capabilities(),
+                            discoveredBy: ["escpos", "rawTcp"]
+                        )
+                        onFound(printer)
+                    }
+                }
+            }
+            browser.start(queue: queue)
+            browsers.append(browser)
+        }
+
+        try? await Task.sleep(nanoseconds: UInt64(timeoutMs) * 1_000_000)
+        browsers.forEach { $0.cancel() }
+        browsers.removeAll()
+    }
+}

package/ios/Plugin/Discovery/DiscoveryManager.swift

@@ -0,0 +1,86 @@
+import Foundation
+
+/// Orchestre la découverte agrégée iOS (miroir de DiscoveryManager.kt).
+///
+/// Sources iOS :
+///   - SDK Epson / Star / Brother / Zebra (via adapters, si liés)
+///   - Bonjour/mDNS réseau (BonjourScanner)
+///   - BLE (optionnel, allowlist)
+///
+/// PAS de Bluetooth Classic générique sur iOS (voir README "Limites iOS").
+final class DiscoveryManager {
+
+    struct Options {
+        let sources: Set<String>?
+        let timeoutMs: Int
+        let networkCidr: String?
+        let tcpPorts: [Int]
+    }
+
+    private let adapters: [PrinterAdapter]
+    init(adapters: [PrinterAdapter]) { self.adapters = adapters }
+
+    func discover(_ options: Options, emitPartial: @escaping (DiscoveredPrinter) -> Void) async -> (printers: [DiscoveredPrinter], failed: [String]) {
+        let buffer = SyncBuffer()
+        var failed: [String] = []
+
+        func enabled(_ src: String) -> Bool { options.sources == nil || options.sources!.contains(src) }
+
+        let collect: (DiscoveredPrinter) -> Void = { p in
+            buffer.add(p)
+            emitPartial(p)
+        }
+
+        await withTaskGroup(of: Void.self) { group in
+            // SDK fabricants
+            for adapter in adapters {
+                let src: String?
+                switch adapter.id {
+                case .epson: src = "epson"
+                case .star: src = "star"
+                case .brother: src = "brother"
+                case .zebra: src = "zebra"
+                default: src = nil
+                }
+                if let src = src, enabled(src), adapter.isAvailable() {
+                    group.addTask { await adapter.discover(timeoutMs: options.timeoutMs, onFound: collect) }
+                }
+            }
+            // Bonjour réseau
+            if enabled("tcp") {
+                group.addTask { await BonjourScanner().scan(timeoutMs: options.timeoutMs, onFound: collect) }
+            }
+            // BLE (optionnel)
+            // if enabled("ble") { group.addTask { await BleScanner().scan(...) } }
+        }
+
+        return (merge(buffer.snapshot()), failed)
+    }
+
+    private func merge(_ incoming: [DiscoveredPrinter]) -> [DiscoveredPrinter] {
+        var byId: [String: DiscoveredPrinter] = [:]
+        for p in incoming {
+            if let existing = byId[p.id] {
+                var winner = AdapterPriority.score(p) > AdapterPriority.score(existing) ? p : existing
+                winner.discoveredBy = existing.discoveredBy.union(p.discoveredBy)
+                winner.lastSeenAt = max(existing.lastSeenAt, p.lastSeenAt)
+                winner.isConnected = existing.isConnected || p.isConnected
+                byId[p.id] = winner
+            } else {
+                byId[p.id] = p
+            }
+        }
+        return byId.values.sorted {
+            let sa = AdapterPriority.score($0), sb = AdapterPriority.score($1)
+            return sa != sb ? sa > sb : $0.name < $1.name
+        }
+    }
+}
+
+/// Petit buffer thread-safe pour collecter les résultats concurrents.
+final class SyncBuffer {
+    private var items: [DiscoveredPrinter] = []
+    private let lock = NSLock()
+    func add(_ p: DiscoveredPrinter) { lock.lock(); items.append(p); lock.unlock() }
+    func snapshot() -> [DiscoveredPrinter] { lock.lock(); defer { lock.unlock() }; return items }
+}

package/ios/Plugin/Image/ImageCache.swift

@@ -0,0 +1,73 @@
+import Foundation
+import CryptoKit
+
+/// Cache local des images à imprimer (miroir de ImageCache.kt).
+/// Emplacement : caches/thermal-images/, clé = SHA-256(url), quota 32 Mo.
+final class ImageCache {
+
+    private let dir: URL
+    private let maxBytes: Int64 = 32 * 1024 * 1024
+
+    init() {
+        let caches = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)[0]
+        dir = caches.appendingPathComponent("thermal-images", isDirectory: true)
+        try? FileManager.default.createDirectory(at: dir, withIntermediateDirectories: true)
+    }
+
+    /// Télécharge l'URL (si absente) et renvoie le chemin local.
+    func fetch(_ urlString: String, timeoutMs: Int = 10000) async throws -> String {
+        guard let url = URL(string: urlString) else {
+            throw PrinterError(.IMAGE_INVALID, "URL invalide: \(urlString)")
+        }
+        let dest = dir.appendingPathComponent(sha256(urlString) + ".img")
+        if FileManager.default.fileExists(atPath: dest.path) {
+            Logger.shared.log("image", "cache hit", ["url": urlString])
+            return dest.path
+        }
+        var request = URLRequest(url: url)
+        request.timeoutInterval = Double(timeoutMs) / 1000.0
+        do {
+            let (data, response) = try await URLSession.shared.data(for: request)
+            if let http = response as? HTTPURLResponse, !(200...299).contains(http.statusCode) {
+                throw PrinterError(.IMAGE_INVALID, "HTTP \(http.statusCode) pour \(urlString)")
+            }
+            try data.write(to: dest)
+            Logger.shared.log("image", "downloaded", ["url": urlString, "bytes": data.count])
+            enforceQuota()
+            return dest.path
+        } catch let e as PrinterError {
+            throw e
+        } catch {
+            throw PrinterError(.IMAGE_INVALID, "Téléchargement image échoué", detail: error.localizedDescription, retryable: true)
+        }
+    }
+
+    private func enforceQuota() {
+        let keys: [URLResourceKey] = [.contentModificationDateKey, .fileSizeKey]
+        guard let files = try? FileManager.default.contentsOfDirectory(at: dir, includingPropertiesForKeys: keys) else { return }
+        let sorted = files.sorted {
+            let d0 = (try? $0.resourceValues(forKeys: [.contentModificationDateKey]).contentModificationDate) ?? .distantPast
+            let d1 = (try? $1.resourceValues(forKeys: [.contentModificationDateKey]).contentModificationDate) ?? .distantPast
+            return d0 < d1
+        }
+        var total = sorted.reduce(Int64(0)) { acc, u in
+            acc + Int64((try? u.resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
+        }
+        var i = 0
+        while total > maxBytes && i < sorted.count {
+            let size = Int64((try? sorted[i].resourceValues(forKeys: [.fileSizeKey]).fileSize) ?? 0)
+            try? FileManager.default.removeItem(at: sorted[i])
+            total -= size
+            i += 1
+        }
+    }
+
+    func clear() {
+        try? FileManager.default.contentsOfDirectory(at: dir, includingPropertiesForKeys: nil)
+            .forEach { try? FileManager.default.removeItem(at: $0) }
+    }
+
+    private func sha256(_ s: String) -> String {
+        SHA256.hash(data: Data(s.utf8)).map { String(format: "%02x", $0) }.joined()
+    }
+}