Adopt root-level tsswift app layout

Move the app payload under swift/ while keeping git, package.json, and .smartconfig.json at the repo root. This standardizes the Swift app setup so build, test, run, and watch workflows match the other repos.
2026-04-19 01:21:43 +02:00
parent d534964601
commit a6939453f8
61 changed files with 2341 additions and 3 deletions
@@ -0,0 +1,193 @@
+import SwiftUI
+
+private let loginAccent = AppTheme.accent
+
+struct LoginRootView: View {
+    @ObservedObject var model: AppViewModel
+    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
+
+    var body: some View {
+        AppScrollScreen(compactLayout: compactLayout) {
+            LoginHeroPanel(model: model, compactLayout: compactLayout)
+            PairingConsoleCard(model: model, compactLayout: compactLayout)
+        }
+        .sheet(isPresented: $model.isScannerPresented) {
+            QRScannerSheet(
+                seededPayload: model.suggestedPairingPayload,
+                title: "Scan linking QR",
+                description: "Use the camera to scan the QR code from the web flow that activates this device as your passport.",
+                navigationTitle: "Scan Linking QR",
+                onCodeScanned: { payload in
+                    model.manualPairingPayload = payload
+                    Task {
+                        await model.signIn(with: payload, transport: .qr)
+                    }
+                }
+            )
+        }
+    }
+
+    private var compactLayout: Bool {
+        #if os(iOS)
+        horizontalSizeClass == .compact
+        #else
+        false
+        #endif
+    }
+}
+
+private struct LoginHeroPanel: View {
+    @ObservedObject var model: AppViewModel
+    let compactLayout: Bool
+
+    var body: some View {
+        AppPanel(compactLayout: compactLayout, radius: AppLayout.largeCardRadius) {
+            AppBadge(title: "Secure passport setup", tone: loginAccent)
+
+            Text("Turn this device into a passport for your idp.global identity")
+                .font(.system(size: compactLayout ? 28 : 36, weight: .bold, design: .rounded))
+                .lineLimit(3)
+
+            Text("Scan a linking QR code or paste a payload to activate this device as your passport for identity proofs and security alerts.")
+                .font(.subheadline)
+                .foregroundStyle(.secondary)
+
+            Divider()
+
+            VStack(alignment: .leading, spacing: 14) {
+                LoginFeatureRow(icon: "qrcode.viewfinder", title: "Scan a QR code from the web flow")
+                LoginFeatureRow(icon: "doc.text.viewfinder", title: "Paste a payload when you already have one")
+                LoginFeatureRow(icon: "iphone.gen3", title: "Handle identity checks and alerts here")
+            }
+
+            if model.isBootstrapping {
+                ProgressView("Preparing preview passport...")
+                    .tint(loginAccent)
+            }
+        }
+    }
+}
+
+private struct LoginFeatureRow: View {
+    let icon: String
+    let title: String
+
+    var body: some View {
+        HStack(alignment: .center, spacing: 12) {
+            Image(systemName: icon)
+                .font(.subheadline.weight(.semibold))
+                .foregroundStyle(loginAccent)
+                .frame(width: 28, height: 28)
+
+            Text(title)
+                .font(.headline)
+
+            Spacer(minLength: 0)
+        }
+    }
+}
+
+private struct PairingConsoleCard: View {
+    @ObservedObject var model: AppViewModel
+    let compactLayout: Bool
+
+    var body: some View {
+        AppSectionCard(title: "Set up passport", compactLayout: compactLayout) {
+            VStack(alignment: .leading, spacing: 8) {
+                Text("Link payload")
+                    .font(.subheadline.weight(.semibold))
+
+                AppTextEditorField(
+                    text: $model.manualPairingPayload,
+                    minHeight: compactLayout ? 132 : 150
+                )
+            }
+
+            if model.isAuthenticating {
+                HStack(spacing: 10) {
+                    ProgressView()
+                    Text("Activating this passport...")
+                        .foregroundStyle(.secondary)
+                }
+            }
+
+            Text("NFC, QR, and OTP proof methods become available after this passport is active.")
+                .font(.footnote)
+                .foregroundStyle(.secondary)
+
+            if compactLayout {
+                VStack(spacing: 12) {
+                    primaryButtons
+                    secondaryButtons
+                }
+            } else {
+                VStack(spacing: 12) {
+                    HStack(spacing: 12) {
+                        primaryButtons
+                    }
+
+                    secondaryButtons
+                }
+            }
+        }
+    }
+
+    @ViewBuilder
+    private var primaryButtons: some View {
+        Button {
+            model.isScannerPresented = true
+        } label: {
+            Label("Scan QR", systemImage: "qrcode.viewfinder")
+                .frame(maxWidth: .infinity)
+        }
+        .buttonStyle(.borderedProminent)
+        .controlSize(.large)
+    }
+
+    @ViewBuilder
+    private var secondaryButtons: some View {
+        if compactLayout {
+            VStack(spacing: 12) {
+                usePayloadButton
+                previewPayloadButton
+            }
+        } else {
+            HStack(spacing: 12) {
+                usePayloadButton
+                previewPayloadButton
+            }
+        }
+    }
+
+    private var usePayloadButton: some View {
+        Button {
+            Task {
+                await model.signInWithManualPayload()
+            }
+        } label: {
+            if model.isAuthenticating {
+                ProgressView()
+                    .frame(maxWidth: .infinity)
+            } else {
+                Label("Link with payload", systemImage: "arrow.right.circle")
+                    .frame(maxWidth: .infinity)
+            }
+        }
+        .buttonStyle(.bordered)
+        .controlSize(.large)
+        .disabled(model.isAuthenticating)
+    }
+
+    private var previewPayloadButton: some View {
+        Button {
+            Task {
+                await model.signInWithSuggestedPayload()
+            }
+        } label: {
+            Label("Use preview passport", systemImage: "wand.and.stars")
+                .frame(maxWidth: .infinity)
+        }
+        .buttonStyle(.bordered)
+        .controlSize(.large)
+    }
+}
@@ -0,0 +1,296 @@
+import SwiftUI
+
+#if canImport(CoreLocation) && canImport(CoreNFC) && canImport(CryptoKit) && os(iOS)
+import CoreLocation
+import CoreNFC
+import CryptoKit
+
+@MainActor
+final class NFCIdentifyReader: NSObject, ObservableObject, @preconcurrency NFCNDEFReaderSessionDelegate {
+    @Published private(set) var helperText: String
+    @Published private(set) var isScanning = false
+    @Published private(set) var isSupported: Bool
+
+    var onAuthenticationRequestDetected: ((PairingAuthenticationRequest) -> Void)?
+    var onError: ((String) -> Void)?
+
+    private let signedGPSPositionProvider = SignedGPSPositionProvider()
+    private var session: NFCNDEFReaderSession?
+    private var isPreparingLocationProof = false
+
+    override init() {
+        let supported = NFCNDEFReaderSession.readingAvailable
+        _helperText = Published(initialValue: supported ? NFCIdentifyReader.idleHelperText : NFCIdentifyReader.unavailableHelperText)
+        _isSupported = Published(initialValue: supported)
+        super.init()
+    }
+
+    func beginScanning() {
+        refreshAvailability()
+
+        guard isSupported else {
+            onError?(Self.unavailableErrorMessage)
+            return
+        }
+
+        guard !isScanning else { return }
+
+        isScanning = true
+        isPreparingLocationProof = false
+        helperText = Self.scanningHelperText
+
+        let session = NFCNDEFReaderSession(delegate: self, queue: nil, invalidateAfterFirstRead: true)
+        session.alertMessage = "Hold your iPhone near the idp.global tag. A signed GPS position will be attached to this NFC identify action."
+        self.session = session
+        session.begin()
+    }
+
+    func readerSessionDidBecomeActive(_ session: NFCNDEFReaderSession) {
+        DispatchQueue.main.async {
+            self.helperText = Self.scanningHelperText
+        }
+    }
+
+    func readerSession(_ session: NFCNDEFReaderSession, didDetectNDEFs messages: [NFCNDEFMessage]) {
+        guard let payload = extractPayload(from: messages) else {
+            session.invalidate()
+            DispatchQueue.main.async {
+                self.finishScanning()
+                self.onError?(Self.invalidTagMessage)
+            }
+            return
+        }
+
+        DispatchQueue.main.async {
+            self.isPreparingLocationProof = true
+            self.helperText = Self.signingLocationHelperText
+
+            Task { @MainActor in
+                await self.completeAuthentication(for: payload)
+            }
+        }
+    }
+
+    func readerSession(_ session: NFCNDEFReaderSession, didInvalidateWithError error: Error) {
+        let nsError = error as NSError
+        let ignoredCodes = [200, 204] // User canceled, first tag read.
+
+        DispatchQueue.main.async {
+            self.session = nil
+        }
+
+        guard !(nsError.domain == NFCErrorDomain && ignoredCodes.contains(nsError.code)) else {
+            if !isPreparingLocationProof {
+                DispatchQueue.main.async {
+                    self.finishScanning()
+                }
+            }
+            return
+        }
+
+        DispatchQueue.main.async {
+            self.finishScanning()
+            self.onError?(Self.failureMessage(for: nsError))
+        }
+    }
+
+    @MainActor
+    private func completeAuthentication(for payload: String) async {
+        do {
+            let signedGPSPosition = try await signedGPSPositionProvider.currentSignedGPSPosition(for: payload)
+            let request = PairingAuthenticationRequest(
+                pairingPayload: payload,
+                transport: .nfc,
+                signedGPSPosition: signedGPSPosition
+            )
+            finishScanning()
+            onAuthenticationRequestDetected?(request)
+        } catch let error as AppError {
+            finishScanning()
+            onError?(error.errorDescription ?? Self.gpsSigningFailureMessage)
+        } catch {
+            finishScanning()
+            onError?(Self.gpsSigningFailureMessage)
+        }
+    }
+
+    private func finishScanning() {
+        session = nil
+        isPreparingLocationProof = false
+        isScanning = false
+        refreshAvailability()
+    }
+
+    private func refreshAvailability() {
+        let available = NFCNDEFReaderSession.readingAvailable
+        isSupported = available
+        if !isScanning {
+            helperText = available ? Self.idleHelperText : Self.unavailableHelperText
+        }
+    }
+
+    private func extractPayload(from messages: [NFCNDEFMessage]) -> String? {
+        for message in messages {
+            for record in message.records {
+                if let url = record.wellKnownTypeURIPayload() {
+                    return url.absoluteString
+                }
+
+                let (text, _) = record.wellKnownTypeTextPayload()
+                if let trimmed = text?.trimmingCharacters(in: .whitespacesAndNewlines),
+                   !trimmed.isEmpty {
+                    return trimmed
+                }
+
+                if let fallback = String(data: record.payload, encoding: .utf8)?
+                    .trimmingCharacters(in: .whitespacesAndNewlines),
+                   !fallback.isEmpty {
+                    return fallback
+                }
+            }
+        }
+
+        return nil
+    }
+
+    private static func failureMessage(for error: NSError) -> String {
+        if error.domain == NFCErrorDomain && error.code == 2 {
+            return "NFC identify is not permitted in this build. Check the NFC entitlement and privacy description."
+        }
+
+        return "NFC identify could not be completed on this device."
+    }
+
+    private static let idleHelperText = "Tap to identify with an NFC tag on supported iPhone hardware. A signed GPS position will be attached automatically."
+    private static let scanningHelperText = "Hold the top of your iPhone near the NFC tag until it is identified."
+    private static let signingLocationHelperText = "Tag detected. Capturing and signing the current GPS position for NFC identify."
+    private static let unavailableHelperText = "NFC identify is unavailable on this device."
+    private static let unavailableErrorMessage = "Tap to identify requires supported iPhone hardware with NFC enabled."
+    private static let invalidTagMessage = "The NFC tag did not contain a usable idp.global payload."
+    private static let gpsSigningFailureMessage = "The NFC tag was read, but the signed GPS position could not be attached."
+}
+
+@MainActor
+private final class SignedGPSPositionProvider: NSObject, @preconcurrency CLLocationManagerDelegate {
+    private var manager: CLLocationManager?
+    private var authorizationContinuation: CheckedContinuation<CLAuthorizationStatus, Never>?
+    private var locationContinuation: CheckedContinuation<CLLocation, Error>?
+
+    func currentSignedGPSPosition(for pairingPayload: String) async throws -> SignedGPSPosition {
+        let location = try await currentLocation()
+        return try sign(location: location, pairingPayload: pairingPayload)
+    }
+
+    private func currentLocation() async throws -> CLLocation {
+        let manager = CLLocationManager()
+        manager.delegate = self
+        manager.desiredAccuracy = kCLLocationAccuracyNearestTenMeters
+        manager.distanceFilter = kCLDistanceFilterNone
+        self.manager = manager
+
+        switch manager.authorizationStatus {
+        case .authorizedAlways, .authorizedWhenInUse:
+            break
+        case .notDetermined:
+            let status = await requestAuthorization(using: manager)
+            guard status == .authorizedAlways || status == .authorizedWhenInUse else {
+                throw AppError.locationPermissionDenied
+            }
+        case .denied, .restricted:
+            throw AppError.locationPermissionDenied
+        @unknown default:
+            throw AppError.locationUnavailable
+        }
+
+        return try await requestLocation(using: manager)
+    }
+
+    private func requestAuthorization(using manager: CLLocationManager) async -> CLAuthorizationStatus {
+        manager.requestWhenInUseAuthorization()
+        return await withCheckedContinuation { continuation in
+            authorizationContinuation = continuation
+        }
+    }
+
+    private func requestLocation(using manager: CLLocationManager) async throws -> CLLocation {
+        try await withCheckedThrowingContinuation { continuation in
+            locationContinuation = continuation
+            manager.requestLocation()
+        }
+    }
+
+    private func sign(location: CLLocation, pairingPayload: String) throws -> SignedGPSPosition {
+        let isFresh = abs(location.timestamp.timeIntervalSinceNow) <= 120
+        guard location.horizontalAccuracy >= 0,
+              isFresh else {
+            throw AppError.locationUnavailable
+        }
+
+        let unsignedPosition = SignedGPSPosition(
+            latitude: location.coordinate.latitude,
+            longitude: location.coordinate.longitude,
+            horizontalAccuracyMeters: location.horizontalAccuracy,
+            capturedAt: location.timestamp
+        )
+
+        let privateKey = P256.Signing.PrivateKey()
+        let signature = try privateKey.signature(for: unsignedPosition.signingPayload(for: pairingPayload))
+        return unsignedPosition.signed(
+            signatureData: signature.derRepresentation,
+            publicKeyData: privateKey.publicKey.x963Representation
+        )
+    }
+
+    func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
+        guard let continuation = authorizationContinuation else { return }
+
+        let status = manager.authorizationStatus
+        guard status != .notDetermined else { return }
+
+        authorizationContinuation = nil
+        continuation.resume(returning: status)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
+        guard let continuation = locationContinuation,
+              let location = locations.last else {
+            return
+        }
+
+        authorizationContinuation = nil
+        locationContinuation = nil
+        self.manager = nil
+        continuation.resume(returning: location)
+    }
+
+    func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
+        guard let continuation = locationContinuation else { return }
+
+        authorizationContinuation = nil
+        locationContinuation = nil
+        self.manager = nil
+
+        if let locationError = error as? CLError,
+           locationError.code == .denied {
+            continuation.resume(throwing: AppError.locationPermissionDenied)
+            return
+        }
+
+        continuation.resume(throwing: AppError.locationUnavailable)
+    }
+}
+#else
+@MainActor
+final class NFCIdentifyReader: NSObject, ObservableObject {
+    @Published private(set) var helperText = "NFC identify with a signed GPS position is available on supported iPhone hardware only."
+    @Published private(set) var isScanning = false
+    @Published private(set) var isSupported = false
+
+    var onAuthenticationRequestDetected: ((PairingAuthenticationRequest) -> Void)?
+    var onError: ((String) -> Void)?
+
+    func beginScanning() {
+        onError?("Tap to identify requires supported iPhone hardware with NFC and location access enabled.")
+    }
+}
+#endif
@@ -0,0 +1,418 @@
+import AVFoundation
+import Combine
+import SwiftUI
+#if os(iOS)
+import UIKit
+#elseif os(macOS)
+import AppKit
+#endif
+
+struct QRScannerSheet: View {
+    let seededPayload: String
+    let title: String
+    let description: String
+    let navigationTitleText: String
+    let onCodeScanned: (String) -> Void
+
+    @Environment(\.dismiss) private var dismiss
+    @Environment(\.horizontalSizeClass) private var horizontalSizeClass
+    @State private var manualFallback = ""
+
+    init(
+        seededPayload: String,
+        title: String = "Scan QR",
+        description: String = "Use the camera to scan an idp.global QR challenge.",
+        navigationTitle: String = "Scan QR",
+        onCodeScanned: @escaping (String) -> Void
+    ) {
+        self.seededPayload = seededPayload
+        self.title = title
+        self.description = description
+        self.navigationTitleText = navigationTitle
+        self.onCodeScanned = onCodeScanned
+    }
+
+    var body: some View {
+        NavigationStack {
+            AppScrollScreen(compactLayout: compactLayout) {
+                AppSectionCard(title: title, compactLayout: compactLayout) {
+                    Text(description)
+                        .font(.subheadline)
+                        .foregroundStyle(.secondary)
+
+                    LiveQRScannerView(onCodeScanned: onCodeScanned)
+                        .frame(minHeight: 340)
+                }
+
+                AppSectionCard(title: "Manual fallback", compactLayout: compactLayout) {
+                    AppTextEditorField(text: $manualFallback, minHeight: 120)
+
+                    if compactLayout {
+                        VStack(spacing: 12) {
+                            useFallbackButton
+                            useSeededButton
+                        }
+                    } else {
+                        HStack(spacing: 12) {
+                            useFallbackButton
+                            useSeededButton
+                        }
+                    }
+                }
+            }
+            .navigationTitle(navigationTitleText)
+            .toolbar {
+                ToolbarItem(placement: .cancellationAction) {
+                    Button("Close") {
+                        dismiss()
+                    }
+                }
+            }
+            .onAppear {
+                manualFallback = seededPayload
+            }
+        }
+    }
+
+    private var compactLayout: Bool {
+        #if os(iOS)
+        horizontalSizeClass == .compact
+        #else
+        false
+        #endif
+    }
+
+    private var useFallbackButton: some View {
+        Button {
+            let chosen = manualFallback.trimmingCharacters(in: .whitespacesAndNewlines)
+            onCodeScanned(chosen.isEmpty ? seededPayload : chosen)
+            dismiss()
+        } label: {
+            Label("Use payload", systemImage: "arrow.up.forward.square")
+                .frame(maxWidth: .infinity)
+        }
+        .buttonStyle(.borderedProminent)
+    }
+
+    private var useSeededButton: some View {
+        Button {
+            manualFallback = seededPayload
+        } label: {
+            Label("Reset sample", systemImage: "wand.and.rays")
+                .frame(maxWidth: .infinity)
+        }
+        .buttonStyle(.bordered)
+    }
+}
+
+private struct LiveQRScannerView: View {
+    let onCodeScanned: (String) -> Void
+
+    @StateObject private var scanner = QRScannerViewModel()
+
+    var body: some View {
+        ZStack(alignment: .bottomLeading) {
+            Group {
+                if scanner.isPreviewAvailable {
+                    ScannerPreview(session: scanner.captureSession)
+                        .clipShape(RoundedRectangle(cornerRadius: 30, style: .continuous))
+                } else {
+                    RoundedRectangle(cornerRadius: 30, style: .continuous)
+                        .fill(Color.black.opacity(0.86))
+
+                    VStack(alignment: .leading, spacing: 12) {
+                        Image(systemName: "video.slash.fill")
+                            .font(.system(size: 28, weight: .semibold))
+                            .foregroundStyle(.white)
+                        Text("Live camera preview unavailable")
+                            .font(.title3.weight(.semibold))
+                            .foregroundStyle(.white)
+                        Text(scanner.statusMessage)
+                            .foregroundStyle(.white.opacity(0.78))
+                    }
+                    .padding(24)
+                }
+            }
+
+            RoundedRectangle(cornerRadius: 30, style: .continuous)
+                .strokeBorder(.white.opacity(0.22), lineWidth: 1.5)
+
+            VStack(alignment: .leading, spacing: 8) {
+                Text("Camera Scanner")
+                    .font(.headline.weight(.semibold))
+                    .foregroundStyle(.white)
+                Text(scanner.statusMessage)
+                    .foregroundStyle(.white.opacity(0.84))
+            }
+            .padding(22)
+
+            ScanFrameOverlay()
+                .padding(40)
+        }
+        .task {
+            scanner.onCodeScanned = { payload in
+                onCodeScanned(payload)
+            }
+            await scanner.start()
+        }
+        .onDisappear {
+            scanner.stop()
+        }
+    }
+}
+
+private struct ScanFrameOverlay: View {
+    var body: some View {
+        GeometryReader { geometry in
+            let size = min(geometry.size.width, geometry.size.height) * 0.5
+
+            RoundedRectangle(cornerRadius: 28, style: .continuous)
+                .strokeBorder(.white.opacity(0.82), style: StrokeStyle(lineWidth: 3, dash: [10, 8]))
+                .frame(width: size, height: size)
+                .position(x: geometry.size.width / 2, y: geometry.size.height / 2)
+        }
+        .allowsHitTesting(false)
+    }
+}
+
+private final class QRScannerViewModel: NSObject, ObservableObject, AVCaptureMetadataOutputObjectsDelegate {
+    @Published var isPreviewAvailable = false
+    @Published var statusMessage = "Point the camera at the QR code from the idp.global web portal."
+
+    let captureSession = AVCaptureSession()
+
+    var onCodeScanned: ((String) -> Void)?
+
+    private let queue = DispatchQueue(label: "global.idp.qrscanner")
+    private var isConfigured = false
+    private var hasDeliveredCode = false
+
+    func start() async {
+        #if os(iOS) && targetEnvironment(simulator)
+        await MainActor.run {
+            isPreviewAvailable = false
+            statusMessage = "The iOS simulator has no live camera feed. Use the seeded payload below."
+        }
+        #else
+        #endif
+
+        #if !(os(iOS) && targetEnvironment(simulator))
+        let authorization = AVCaptureDevice.authorizationStatus(for: .video)
+        switch authorization {
+        case .authorized:
+            await configureIfNeeded()
+            startRunning()
+        case .notDetermined:
+            let granted = await requestCameraAccess()
+            await MainActor.run {
+                self.statusMessage = granted
+                    ? "Point the camera at the QR code from the idp.global web portal."
+                    : "Camera access was denied. Use the fallback payload below."
+            }
+            guard granted else { return }
+            await configureIfNeeded()
+            startRunning()
+        case .denied, .restricted:
+            await MainActor.run {
+                isPreviewAvailable = false
+                statusMessage = "Camera access is unavailable. Use the fallback payload below."
+            }
+        @unknown default:
+            await MainActor.run {
+                isPreviewAvailable = false
+                statusMessage = "Camera access could not be initialized on this device."
+            }
+        }
+        #endif
+    }
+
+    func stop() {
+        queue.async {
+            if self.captureSession.isRunning {
+                self.captureSession.stopRunning()
+            }
+        }
+    }
+
+    func metadataOutput(
+        _ output: AVCaptureMetadataOutput,
+        didOutput metadataObjects: [AVMetadataObject],
+        from connection: AVCaptureConnection
+    ) {
+        guard !hasDeliveredCode,
+              let readable = metadataObjects.first as? AVMetadataMachineReadableCodeObject,
+              readable.type == .qr,
+              let payload = readable.stringValue else {
+            return
+        }
+
+        hasDeliveredCode = true
+        stop()
+
+        #if os(iOS)
+        UINotificationFeedbackGenerator().notificationOccurred(.success)
+        #endif
+
+        DispatchQueue.main.async { [onCodeScanned] in
+            onCodeScanned?(payload)
+        }
+    }
+
+    private func requestCameraAccess() async -> Bool {
+        await withCheckedContinuation { continuation in
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                continuation.resume(returning: granted)
+            }
+        }
+    }
+
+    private func configureIfNeeded() async {
+        guard !isConfigured else {
+            await MainActor.run {
+                self.isPreviewAvailable = true
+            }
+            return
+        }
+
+        await withCheckedContinuation { (continuation: CheckedContinuation<Void, Never>) in
+            queue.async {
+                self.captureSession.beginConfiguration()
+                defer {
+                    self.captureSession.commitConfiguration()
+                    continuation.resume()
+                }
+
+                guard let device = AVCaptureDevice.default(for: .video) else {
+                    DispatchQueue.main.async {
+                        self.isPreviewAvailable = false
+                        self.statusMessage = "No compatible camera was found. Use the fallback payload below."
+                    }
+                    return
+                }
+
+                guard let input = try? AVCaptureDeviceInput(device: device) else {
+                    DispatchQueue.main.async {
+                        self.isPreviewAvailable = false
+                        self.statusMessage = "No compatible camera was found. Use the fallback payload below."
+                    }
+                    return
+                }
+
+                guard self.captureSession.canAddInput(input) else {
+                    DispatchQueue.main.async {
+                        self.isPreviewAvailable = false
+                        self.statusMessage = "No compatible camera was found. Use the fallback payload below."
+                    }
+                    return
+                }
+
+                self.captureSession.addInput(input)
+
+                let output = AVCaptureMetadataOutput()
+                guard self.captureSession.canAddOutput(output) else {
+                    self.captureSession.removeInput(input)
+                    DispatchQueue.main.async {
+                        self.isPreviewAvailable = false
+                        self.statusMessage = "Unable to configure QR metadata scanning on this device."
+                    }
+                    return
+                }
+
+                self.captureSession.addOutput(output)
+                output.setMetadataObjectsDelegate(self, queue: DispatchQueue.main)
+
+                let supportedTypes = output.availableMetadataObjectTypes
+                guard supportedTypes.contains(.qr) else {
+                    self.captureSession.removeOutput(output)
+                    self.captureSession.removeInput(input)
+                    DispatchQueue.main.async {
+                        self.isPreviewAvailable = false
+                        self.statusMessage = "This camera does not support QR metadata scanning. Use the fallback payload below."
+                    }
+                    return
+                }
+
+                output.metadataObjectTypes = [.qr]
+                self.isConfigured = true
+
+                DispatchQueue.main.async {
+                    self.isPreviewAvailable = true
+                    self.statusMessage = "Point the camera at the QR code from the idp.global web portal."
+                }
+            }
+        }
+    }
+
+    private func startRunning() {
+        queue.async {
+            guard !self.captureSession.isRunning else { return }
+            self.hasDeliveredCode = false
+            self.captureSession.startRunning()
+        }
+    }
+}
+
+extension QRScannerViewModel: @unchecked Sendable {}
+
+#if os(iOS)
+private struct ScannerPreview: UIViewRepresentable {
+    let session: AVCaptureSession
+
+    func makeUIView(context: Context) -> ScannerPreviewUIView {
+        let view = ScannerPreviewUIView()
+        view.previewLayer.session = session
+        view.previewLayer.videoGravity = .resizeAspectFill
+        return view
+    }
+
+    func updateUIView(_ uiView: ScannerPreviewUIView, context: Context) {
+        uiView.previewLayer.session = session
+    }
+}
+
+private final class ScannerPreviewUIView: UIView {
+    override class var layerClass: AnyClass {
+        AVCaptureVideoPreviewLayer.self
+    }
+
+    var previewLayer: AVCaptureVideoPreviewLayer {
+        layer as! AVCaptureVideoPreviewLayer
+    }
+}
+#elseif os(macOS)
+private struct ScannerPreview: NSViewRepresentable {
+    let session: AVCaptureSession
+
+    func makeNSView(context: Context) -> ScannerPreviewNSView {
+        let view = ScannerPreviewNSView()
+        view.attach(session: session)
+        return view
+    }
+
+    func updateNSView(_ nsView: ScannerPreviewNSView, context: Context) {
+        nsView.attach(session: session)
+    }
+}
+
+private final class ScannerPreviewNSView: NSView {
+    private var previewLayer: AVCaptureVideoPreviewLayer?
+
+    override init(frame frameRect: NSRect) {
+        super.init(frame: frameRect)
+        wantsLayer = true
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        wantsLayer = true
+    }
+
+    func attach(session: AVCaptureSession) {
+        let layer = previewLayer ?? AVCaptureVideoPreviewLayer(session: session)
+        layer.session = session
+        layer.videoGravity = .resizeAspectFill
+        self.layer = layer
+        previewLayer = layer
+    }
+}
+#endif