feat(apple): native SwiftUI app for iOS and macOS

Add a native SwiftUI VniDrop app (Send/Receive/Settings) talking to the
Rust core via generated UniFFI Swift bindings, plus the uniffi-bindgen
helper crate. iOS uses a TabView, macOS a NavigationSplitView sidebar.

apple/VniDrop/Features/App/AppModel.swift

@@ -0,0 +1,44 @@
+import Foundation
+import Combine
+
+/// Top-level app state, ported from `feature/app/AppViewModel.kt`. Initializes the
+/// core on launch and tracks the selected destination + theme.
+@MainActor
+final class AppModel: ObservableObject {
+	@Published private(set) var destination: AppDestination = .send
+	@Published private(set) var themeMode: ThemeMode = .system
+
+	private let environment: PlatformEnvironment
+	private let repository: CoreRepository
+	private let messages: UiMessageController
+	private var cancellables = Set<AnyCancellable>()
+
+	init(
+		environment: PlatformEnvironment,
+		repository: CoreRepository,
+		preferences: AppPreferencesRepository,
+		messages: UiMessageController
+	) {
+		self.environment = environment
+		self.repository = repository
+		self.messages = messages
+
+		AppLogger.info("lifecycle", "app started", ["platform": environment.name])
+
+		Task {
+			let result = await repository.initialize(appDataDir: environment.defaultCoreDataDir)
+			if case .failure(let error) = result { messages.error(error) }
+		}
+
+		preferences.$preferences
+			.map(\.themeMode)
+			.removeDuplicates()
+			.sink { [weak self] mode in self?.themeMode = mode }
+			.store(in: &cancellables)
+	}
+
+	func selectDestination(_ destination: AppDestination) {
+		guard destination != self.destination else { return }
+		self.destination = destination
+	}
+}

apple/VniDrop/Features/Approvals/ApprovalCoordinator.swift

@@ -0,0 +1,179 @@
+import Foundation
+import Combine
+
+/// A pending receiver approval, ported from `feature/approvals/ApprovalCoordinator.kt`.
+struct PendingApproval: Equatable, Identifiable {
+	let id: String
+	let transferId: UInt64
+	let transferName: String
+	let receiverName: String?
+	let receiverDeviceName: String?
+	/// Cryptographic peer identity — not display-name spoofable.
+	let remoteEndpointId: String
+	let requestedAt: Int64
+}
+
+struct ApprovalState: Equatable {
+	var pending: [PendingApproval] = []
+	var respondingIds: Set<String> = []
+
+	var current: PendingApproval? { pending.first }
+}
+
+/// Drives receiver-approval prompts and their notifications, ported from
+/// `ApprovalCoordinator.kt`.
+@MainActor
+final class ApprovalCoordinator: ObservableObject {
+	@Published private(set) var state = ApprovalState()
+
+	private let repository: CoreRepository
+	private let preferences: AppPreferencesRepository
+	private let notifications: LocalNotificationService
+	private let visibility: AppVisibility
+	private let messages: UiMessageController
+
+	private var publishedNotificationIds = Set<String>()
+	private var cancellables = Set<AnyCancellable>()
+
+	init(
+		repository: CoreRepository,
+		preferences: AppPreferencesRepository,
+		notifications: LocalNotificationService,
+		visibility: AppVisibility,
+		messages: UiMessageController
+	) {
+		self.repository = repository
+		self.preferences = preferences
+		self.notifications = notifications
+		self.visibility = visibility
+		self.messages = messages
+
+		repository.signals
+			.sink { [weak self] signal in
+				guard let self else { return }
+				if case .approvalChanged(let transferId) = signal {
+					Task { await self.refresh(transferId: transferId) }
+				}
+			}
+			.store(in: &cancellables)
+
+		repository.$state
+			.sink { [weak self] core in
+				guard let self, core.isInitialized else { return }
+				let sharing = core.transfers.filter { $0.direction == .send && $0.status == .sharing }
+				for transfer in sharing {
+					Task { await self.refresh(transferId: transfer.transferId) }
+				}
+			}
+			.store(in: &cancellables)
+
+		// Recompute notifications when any input changes.
+		Publishers.CombineLatest4(
+			preferences.$preferences,
+			visibility.$isForeground,
+			$state,
+			notifications.$permission
+		)
+		.sink { [weak self] preferences, foreground, approvalState, permission in
+			guard let self else { return }
+			Task {
+				await self.synchronizeNotifications(
+					enabled: preferences.notificationsEnabled,
+					foreground: foreground,
+					pending: approvalState.pending,
+					permission: permission
+				)
+			}
+		}
+		.store(in: &cancellables)
+	}
+
+	func accept(_ requestId: String) { respond(requestId, accepted: true) }
+	func refuse(_ requestId: String) { respond(requestId, accepted: false) }
+
+	private func respond(_ requestId: String, accepted: Bool) {
+		guard !state.respondingIds.contains(requestId) else { return }
+		state.respondingIds.insert(requestId)
+		Task {
+			let request = state.pending.first { $0.id == requestId }
+			let result = await repository.respondReceiverRequest(
+				requestId: requestId,
+				accepted: accepted,
+				reason: accepted ? nil : "sender-refused"
+			)
+			state.respondingIds.remove(requestId)
+			switch result {
+			case .success:
+				if let request { await refresh(transferId: request.transferId) }
+			case .failure(let error):
+				messages.error(error)
+			}
+		}
+	}
+
+	private func refresh(transferId: UInt64) async {
+		let result = await repository.receiverRequests(transferId: transferId)
+		switch result {
+		case .success(let requests):
+			let refreshed = requests
+				.filter { $0.status == .requested }
+				.map { $0.toPending() }
+			let refreshedIds = Set(refreshed.map { $0.id })
+			let removed = Set(state.pending.filter { $0.transferId == transferId }.map { $0.id })
+				.subtracting(refreshedIds)
+			for id in removed {
+				notifications.cancel(id: Self.notificationId(id))
+				publishedNotificationIds.remove(id)
+			}
+			var pending = state.pending.filter { $0.transferId != transferId } + refreshed
+			// distinctBy id, sorted by requestedAt
+			var seen = Set<String>()
+			pending = pending.filter { seen.insert($0.id).inserted }
+				.sorted { $0.requestedAt < $1.requestedAt }
+			state.pending = pending
+		case .failure(let error):
+			messages.error(error)
+		}
+	}
+
+	private func synchronizeNotifications(
+		enabled: Bool,
+		foreground: Bool,
+		pending: [PendingApproval],
+		permission: NotificationPermission
+	) async {
+		if foreground || !enabled || permission != .granted {
+			notifications.cancelAll()
+			return
+		}
+		for request in pending where !publishedNotificationIds.contains(request.id) {
+			let receiver = request.receiverName
+				?? request.receiverDeviceName
+				?? String(localized: "approval_nearby_device")
+			let title = String(localized: "approval_connection_request")
+			let body = String(
+				format: String(localized: "approval_request_body"),
+				receiver, request.transferName
+			)
+			let result = await notifications.publish(
+				LocalNotification(id: Self.notificationId(request.id), title: title, body: body)
+			)
+			switch result {
+			case .success: publishedNotificationIds.insert(request.id)
+			case .failure(let error): messages.error(error)
+			}
+		}
+	}
+
+	private static func notificationId(_ requestId: String) -> String { "approval-\(requestId)" }
+}
+
+private extension ReceiverRequestModel {
+	func toPending() -> PendingApproval {
+		PendingApproval(
+			id: id, transferId: transferId, transferName: transferName,
+			receiverName: receiverName, receiverDeviceName: receiverDeviceName,
+			remoteEndpointId: remoteEndpointId, requestedAt: requestedAt
+		)
+	}
+}

apple/VniDrop/Features/Approvals/ApprovalModal.swift

@@ -0,0 +1,73 @@
+import SwiftUI
+
+/// Non-dismissable receiver-approval modal, presented as a native sheet that can't
+/// be swiped away. The endpoint id is the trusted identity; display names are
+/// peer-provided.
+struct ApprovalModalHost: View {
+	let state: ApprovalState
+	let onAccept: (String) -> Void
+	let onRefuse: (String) -> Void
+
+	var body: some View {
+		Color.clear
+			.sheet(isPresented: .constant(state.current != nil)) {
+				if let request = state.current {
+					ApprovalSheet(state: state, request: request, onAccept: onAccept, onRefuse: onRefuse)
+						.interactiveDismissDisabled(true)
+						.modifier(ApprovalDetents())
+				}
+			}
+	}
+}
+
+private struct ApprovalDetents: ViewModifier {
+	func body(content: Content) -> some View {
+		#if os(iOS)
+		content.presentationDetents([.medium])
+		#else
+		content.frame(minWidth: 420, minHeight: 320)
+		#endif
+	}
+}
+
+private struct ApprovalSheet: View {
+	let state: ApprovalState
+	let request: PendingApproval
+	let onAccept: (String) -> Void
+	let onRefuse: (String) -> Void
+
+	var body: some View {
+		let busy = state.respondingIds.contains(request.id)
+		let receiver = request.receiverName ?? request.receiverDeviceName ?? String(localized: "approval_nearby_device")
+		VStack(spacing: 16) {
+			Image(systemName: "checkmark.shield.fill")
+				.font(.system(size: 44))
+				.foregroundStyle(.tint)
+				.padding(.top, 12)
+			Text(LocalizedStringKey("approval_connection_request"))
+				.font(.title2).fontWeight(.semibold)
+			Text(String(format: String(localized: "approval_request_body"), receiver, request.transferName))
+				.multilineTextAlignment(.center)
+			Text(String(format: String(localized: "approval_endpoint_id"), request.remoteEndpointId))
+				.font(.caption).foregroundStyle(.secondary)
+				.multilineTextAlignment(.center)
+			if state.pending.count > 1 {
+				Text(String(format: String(localized: "approval_pending_count"), state.pending.count))
+					.font(.caption).foregroundStyle(.secondary)
+			}
+			Spacer(minLength: 0)
+			if busy { ProgressView() }
+			VStack(spacing: 10) {
+				Button(action: { onAccept(request.id) }) {
+					Text(LocalizedStringKey("button_approve")).frame(maxWidth: .infinity)
+				}
+				.buttonStyle(.borderedProminent).controlSize(.large).disabled(busy)
+				Button(role: .destructive, action: { onRefuse(request.id) }) {
+					Text(LocalizedStringKey("button_refuse")).frame(maxWidth: .infinity)
+				}
+				.buttonStyle(.bordered).controlSize(.large).disabled(busy)
+			}
+		}
+		.padding(24)
+	}
+}

apple/VniDrop/Features/Receive/ReceiveInvitationActions.swift

@@ -0,0 +1,146 @@
+import SwiftUI
+
+enum ReceiveMethodAvailability { case available, unavailable, hidden }
+
+/// Invitation acquisition actions, ported from `ReceiveInvitationActions` (iosMain).
+@MainActor
+protocol ReceiveInvitationActions: AnyObject {
+	var fileAvailability: ReceiveMethodAvailability { get }
+	var qrAvailability: ReceiveMethodAvailability { get }
+	var nfcAvailability: ReceiveMethodAvailability { get }
+
+	func pickInvitation(onResult: @escaping (Result<String, Error>) -> Void)
+	func scanQrCode(onResult: @escaping (Result<String, Error>) -> Void)
+	func readNfcInvitation(onResult: @escaping (Result<String, Error>) -> Void)
+	func cancel()
+}
+
+/// Method chooser panel, ported from `ReceiveMethodPanel` in `ReceiveScreen.kt`.
+struct ReceiveMethodPanel: View {
+	@Environment(\.vniColors) private var colors
+	@ObservedObject var model: ReceiveModel
+	@State private var actions: ReceiveInvitationActions = makeReceiveInvitationActions()
+
+	var body: some View {
+		VStack(alignment: .leading, spacing: 12) {
+			Text(LocalizedStringKey("receive_choose_method_title")).font(VniType.titleLarge)
+			Text(LocalizedStringKey("receive_choose_method_body")).foregroundStyle(colors.foregroundLighter)
+
+			MethodRow(
+				icon: "doc", titleKey: "receive_method_file", descKey: "receive_method_file_description",
+				availability: actions.fileAvailability
+			) { actions.pickInvitation { model.onInvitationResult(.invitationFile, $0) } }
+
+			if actions.qrAvailability != .hidden {
+				MethodRow(
+					icon: "qrcode.viewfinder", titleKey: "receive_method_scan", descKey: "receive_method_scan_description",
+					availability: actions.qrAvailability
+				) { actions.scanQrCode { model.onInvitationResult(.qrCode, $0) } }
+			}
+			if actions.nfcAvailability != .hidden {
+				MethodRow(
+					icon: "wave.3.right",
+					titleOverride: model.state.isWaitingForNfc ? String(localized: "receive_nfc_waiting") : nil,
+					titleKey: "receive_method_nfc", descKey: "receive_method_nfc_description",
+					availability: model.state.isWaitingForNfc ? .unavailable : actions.nfcAvailability
+				) {
+					model.setWaitingForNfc(true)
+					actions.readNfcInvitation { model.onInvitationResult(.nfc, $0) }
+				}
+			}
+		}
+		.padding(.horizontal, 20).padding(.vertical, 14)
+		.frame(maxWidth: .infinity, alignment: .leading)
+	}
+}
+
+private struct MethodRow: View {
+	@Environment(\.vniColors) private var colors
+	let icon: String
+	var titleOverride: String? = nil
+	let titleKey: String
+	let descKey: String
+	let availability: ReceiveMethodAvailability
+	let onTap: () -> Void
+
+	var body: some View {
+		let enabled = availability == .available
+		Button(action: onTap) {
+			HStack(spacing: 14) {
+				Image(systemName: icon).font(.system(size: 22))
+					.foregroundStyle(enabled ? colors.brandLink : colors.foregroundLighter)
+					.frame(width: 24)
+				VStack(alignment: .leading, spacing: 3) {
+					if let titleOverride {
+						Text(titleOverride).font(VniType.bodyLarge)
+					} else {
+						Text(LocalizedStringKey(titleKey)).font(VniType.bodyLarge)
+					}
+					Text(LocalizedStringKey(descKey)).font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+				}
+				Spacer()
+				if availability == .unavailable {
+					Text(LocalizedStringKey("value_unavailable")).font(VniType.labelSmall).foregroundStyle(colors.foregroundLighter)
+				}
+			}
+			.padding(16)
+			.frame(maxWidth: .infinity)
+			.background(colors.backgroundSurface200, in: RoundedRectangle(cornerRadius: 14))
+			.contentShape(Rectangle())
+		}
+		.buttonStyle(.plain)
+		.disabled(!enabled)
+	}
+}
+
+/// Invitation review panel, ported from `InvitationReviewPanel` in `ReceiveScreen.kt`.
+struct InvitationReviewPanel: View {
+	@Environment(\.vniColors) private var colors
+	@ObservedObject var model: ReceiveModel
+
+	private var state: ReceiveState { model.state }
+
+	var body: some View {
+		VStack(alignment: .leading, spacing: 14) {
+			Text(LocalizedStringKey("receive_review_title")).font(VniType.titleLarge)
+			if state.isInspecting {
+				ProgressView().frame(maxWidth: .infinity).padding(40)
+			}
+			if let inspection = state.inspection {
+				let metadata = inspection.metadata
+				VStack(alignment: .leading, spacing: 8) {
+					Text(metadata.transferName).font(VniType.bodyLarge).lineLimit(2)
+					Text("\(metadata.fileCount) \(String(localized: "metadata_files").lowercased()) · \(formatBytes(metadata.totalSize))")
+						.foregroundStyle(colors.foregroundLighter)
+				}
+				.padding(16)
+				.frame(maxWidth: .infinity, alignment: .leading)
+				.background(colors.backgroundSurface200, in: RoundedRectangle(cornerRadius: 14))
+
+				Field(label: String(localized: "field_receiver_name"),
+					  value: Binding(get: { state.receiverName }, set: model.setReceiverName))
+				Text(state.receiveFolder?.displayName ?? String(localized: "value_unavailable"))
+					.font(VniType.bodySmall)
+					.foregroundStyle(state.folderAccessStatus == .writable ? colors.foregroundLight : colors.destructiveDefault)
+
+				if state.isReceiving {
+					let progressId = state.activeReceiveTransferId
+						?? model.coreState.events.first { $0.direction == "receive" && $0.transferId != nil }?.transferId
+					let progress = progressId.flatMap { progressForTransfer(events: model.coreState.events, transferId: $0) }
+					ProgressRow(labelKey: progress?.labelKey ?? "progress_receiving", progress: progress?.progress, detail: progress?.detail)
+					SecondaryButton(title: String(localized: "button_cancel_receive"), action: model.cancelActiveReceive)
+				} else {
+					PrimaryButton(
+						title: String(localized: "button_receive"), action: model.receive,
+						enabled: state.canReceive(coreInitialized: model.coreState.isInitialized)
+					)
+				}
+				if let error = state.lastReceiveError {
+					Text(error.resolved()).font(VniType.bodySmall).foregroundStyle(colors.destructiveDefault)
+				}
+			}
+		}
+		.padding(.horizontal, 20).padding(.vertical, 14)
+		.frame(maxWidth: .infinity, alignment: .leading)
+	}
+}

apple/VniDrop/Features/Receive/ReceiveModel.swift

@@ -0,0 +1,265 @@
+import Foundation
+import Combine
+
+/// Which acquisition method produced an invitation, ported from `ReceiveMethod`.
+enum ReceiveMethod {
+	case invitationFile
+	case qrCode
+	case nfc
+}
+
+enum ReceiveHistoryDeleteTarget: Equatable {
+	case transfer(transferId: UInt64)
+	case all
+}
+
+/// Receive feature state, ported from `feature/receive/ReceiveViewModel.kt`.
+struct ReceiveState: Equatable {
+	var isAcquisitionOpen = false
+	var ticket = ""
+	var method: ReceiveMethod?
+	var inspection: TicketInspectionModel?
+	var receiverName = ""
+	var receiveFolder: ReceiveFolder?
+	var folderAccessStatus: FolderAccessStatus = .unavailable
+	var isInspecting = false
+	var isReceiving = false
+	var activeReceiveTransferId: UInt64?
+	var lastReceiveError: UiText?
+	var isWaitingForNfc = false
+	var historyDeleteTarget: ReceiveHistoryDeleteTarget?
+	var isDeletingHistory = false
+
+	func canReceive(coreInitialized: Bool) -> Bool {
+		coreInitialized && !ticket.isEmpty && inspection != nil
+			&& folderAccessStatus == .writable && !isReceiving && !isInspecting
+	}
+
+	static func == (lhs: ReceiveState, rhs: ReceiveState) -> Bool {
+		lhs.isAcquisitionOpen == rhs.isAcquisitionOpen && lhs.ticket == rhs.ticket
+			&& lhs.inspection == rhs.inspection && lhs.receiverName == rhs.receiverName
+			&& lhs.receiveFolder == rhs.receiveFolder && lhs.folderAccessStatus == rhs.folderAccessStatus
+			&& lhs.isInspecting == rhs.isInspecting && lhs.isReceiving == rhs.isReceiving
+			&& lhs.activeReceiveTransferId == rhs.activeReceiveTransferId
+			&& lhs.lastReceiveError == rhs.lastReceiveError && lhs.isWaitingForNfc == rhs.isWaitingForNfc
+			&& lhs.historyDeleteTarget == rhs.historyDeleteTarget && lhs.isDeletingHistory == rhs.isDeletingHistory
+	}
+}
+
+@MainActor
+final class ReceiveModel: ObservableObject {
+	@Published private(set) var state = ReceiveState()
+	@Published private(set) var coreState = CoreState()
+
+	private let repository: CoreRepository
+	private let fileSystemService: FileSystemService
+	private let messages: UiMessageController
+	private var cancellables = Set<AnyCancellable>()
+
+	init(
+		repository: CoreRepository,
+		fileSystemService: FileSystemService,
+		preferences: AppPreferencesRepository,
+		messages: UiMessageController
+	) {
+		self.repository = repository
+		self.fileSystemService = fileSystemService
+		self.messages = messages
+
+		repository.$state.sink { [weak self] in self?.coreState = $0 }.store(in: &cancellables)
+
+		preferences.$preferences
+			.sink { [weak self] prefs in
+				guard let self else { return }
+				Task {
+					let folder = self.fileSystemService.effectiveReceiveFolder(prefs.receiveFolder)
+					let status = await self.fileSystemService.validateReceiveFolder(folder)
+					if self.state.receiverName.isEmpty { self.state.receiverName = prefs.username }
+					self.state.receiveFolder = folder
+					self.state.folderAccessStatus = status
+				}
+			}
+			.store(in: &cancellables)
+
+		repository.signals
+			.sink { [weak self] signal in
+				guard let self else { return }
+				if case .transfersChanged(let id) = signal {
+					Task { _ = await self.repository.refresh() }
+					if self.state.isReceiving && id != 0 {
+						self.state.activeReceiveTransferId = id
+					}
+				}
+			}
+			.store(in: &cancellables)
+	}
+
+	func openAcquisition() { state.isAcquisitionOpen = true }
+	func dismissAcquisition() {
+		if !state.isReceiving && !state.isInspecting { resetAcquisition() }
+	}
+	func setReceiverName(_ value: String) { state.receiverName = value }
+	func setWaitingForNfc(_ waiting: Bool) { state.isWaitingForNfc = waiting }
+
+	func requestDeleteHistoryItem(_ transferId: UInt64) {
+		let canDelete = coreState.transfers.contains {
+			$0.transferId == transferId && $0.direction == .receive && $0.status.isTerminalReceiveHistory
+		}
+		if canDelete { state.historyDeleteTarget = .transfer(transferId: transferId) }
+	}
+
+	func requestClearHistory() {
+		if coreState.transfers.contains(where: { $0.direction == .receive && $0.status.isTerminalReceiveHistory }) {
+			state.historyDeleteTarget = .all
+		}
+	}
+
+	func dismissHistoryDelete() {
+		if !state.isDeletingHistory { state.historyDeleteTarget = nil }
+	}
+
+	func confirmHistoryDelete() {
+		guard let target = state.historyDeleteTarget, !state.isDeletingHistory else { return }
+		state.isDeletingHistory = true
+		Task {
+			let result: Result<Void, Error>
+			switch target {
+			case .transfer(let id):
+				result = await repository.delete(transferId: id)
+			case .all:
+				result = (await repository.clearReceiveHistory()).map { _ in () }
+			}
+			switch result {
+			case .success:
+				state.historyDeleteTarget = nil
+				state.isDeletingHistory = false
+				let key = target == .all ? "receive_history_cleared" : "transfer_deleted"
+				messages.tryShow(UiMessage(text: .resource(key), tone: .success))
+			case .failure(let error):
+				state.isDeletingHistory = false
+				messages.error(error)
+			}
+		}
+	}
+
+	func onInvitationResult(_ method: ReceiveMethod, _ result: Result<String, Error>) {
+		state.isWaitingForNfc = false
+		switch result {
+		case .success(let raw): inspectInvitation(method, raw)
+		case .failure(let error): messages.error(error)
+		}
+	}
+
+	func receive() {
+		let current = state
+		guard let folder = current.receiveFolder else { return }
+		if !current.canReceive(coreInitialized: coreState.isInitialized) { return }
+		state.isReceiving = true
+		state.lastReceiveError = nil
+		state.activeReceiveTransferId = nil
+		Task {
+			let result: Result<Void, Error>
+			if folder.kind == .iosSecurityScopedUrl {
+				result = await repository.receiveIntoSecurityScopedDirectory(
+					ticket: current.ticket, outputDirectoryUrl: folder.value, receiverName: current.receiverName
+				)
+			} else {
+				result = await repository.receive(
+					ticket: current.ticket, outputDir: folder.value, receiverName: current.receiverName
+				)
+			}
+			switch result {
+			case .success:
+				resetAcquisition()
+				let canReveal = fileSystemService.canRevealReceiveFolder(folder)
+				messages.tryShow(UiMessage(
+					text: .resource("receive_completed"),
+					tone: .success,
+					actionLabel: canReveal ? .resource("button_show_in_files") : nil,
+					onAction: canReveal ? { [weak self] in self?.revealReceiveFolder(folder) } : nil
+				))
+			case .failure(let error):
+				if error.isUserCancellation {
+					state.isReceiving = false
+					state.activeReceiveTransferId = nil
+					state.lastReceiveError = nil
+					return
+				}
+				let uiText = error.toUiText()
+				state.isReceiving = false
+				state.activeReceiveTransferId = nil
+				state.lastReceiveError = uiText
+				messages.tryShow(UiMessage(
+					text: uiText,
+					tone: .error,
+					actionLabel: .resource("button_retry"),
+					onAction: { [weak self] in self?.receive() }
+				))
+			}
+		}
+	}
+
+	func cancelActiveReceive() {
+		let transferId = state.activeReceiveTransferId
+			?? coreState.transfers.first { $0.direction == .receive && $0.status == .receiving }?.transferId
+			?? coreState.events.first { $0.direction == "receive" && $0.transferId != nil }?.transferId
+		guard let transferId else { return }
+		Task {
+			let result = await repository.cancel(transferId: transferId)
+			switch result {
+			case .success:
+				state.isReceiving = false
+				state.activeReceiveTransferId = nil
+				state.lastReceiveError = nil
+				_ = await repository.refresh()
+			case .failure(let error):
+				messages.error(error)
+			}
+		}
+	}
+
+	private func revealReceiveFolder(_ folder: ReceiveFolder) {
+		Task {
+			let result = await fileSystemService.revealReceiveFolder(folder)
+			if case .failure = result {
+				messages.show(UiMessage(text: .resource("receive_open_files_failed"), tone: .error))
+			}
+		}
+	}
+
+	private func inspectInvitation(_ method: ReceiveMethod, _ raw: String) {
+		let ticket = raw.trimmingCharacters(in: .whitespacesAndNewlines)
+		if ticket.isEmpty { return messages.error(.resource("error_invitation_empty")) }
+		state.isAcquisitionOpen = true
+		state.ticket = ticket
+		state.method = method
+		state.inspection = nil
+		state.isInspecting = true
+		Task {
+			let result = await repository.inspectTicket(ticket)
+			switch result {
+			case .success(let inspection):
+				state.inspection = inspection
+				state.isInspecting = false
+			case .failure(let error):
+				state.ticket = ""
+				state.method = nil
+				state.inspection = nil
+				state.isInspecting = false
+				messages.error(error)
+			}
+		}
+	}
+
+	private func resetAcquisition() {
+		state.isAcquisitionOpen = false
+		state.ticket = ""
+		state.method = nil
+		state.inspection = nil
+		state.isInspecting = false
+		state.isReceiving = false
+		state.activeReceiveTransferId = nil
+		state.lastReceiveError = nil
+		state.isWaitingForNfc = false
+	}
+}

apple/VniDrop/Features/Receive/ReceiveScreen.swift

@@ -0,0 +1,149 @@
+import SwiftUI
+
+/// Receive screen, rebuilt on native SwiftUI. A grouped `List` of received
+/// transfers with swipe-to-delete, and the acquisition flow as a native sheet.
+struct ReceiveScreen: View {
+	@ObservedObject var model: ReceiveModel
+	let windowClass: WindowClass
+
+	private var transfers: [Transfer] {
+		model.coreState.transfers.filter { $0.direction == .receive }
+	}
+	private var deletable: [Transfer] {
+		transfers.filter { $0.status.isTerminalReceiveHistory }
+	}
+
+	var body: some View {
+		NavigationStack {
+			Group {
+				if transfers.isEmpty {
+					ScrollView { emptyState }
+				} else {
+					history
+				}
+			}
+			.navigationTitle(Text(LocalizedStringKey("receive_title")))
+			.toolbar {
+				ToolbarItem(placement: .primaryAction) {
+					Button(action: model.openAcquisition) {
+						Label(String(localized: "button_receive_files"), systemImage: "plus")
+					}
+				}
+				if !deletable.isEmpty {
+					ToolbarItem(placement: .primaryAction) {
+						Button(role: .destructive, action: model.requestClearHistory) {
+							Label(String(localized: "receive_clear_history"), systemImage: "trash")
+						}
+					}
+				}
+			}
+		}
+		.adaptiveDrawer(
+			isPresented: Binding(get: { model.state.isAcquisitionOpen }, set: { _ in }),
+			windowClass: windowClass,
+			onDismiss: model.dismissAcquisition
+		) {
+			if model.state.ticket.isEmpty {
+				ReceiveMethodPanel(model: model)
+			} else {
+				InvitationReviewPanel(model: model)
+			}
+		}
+		.alert(
+			Text(LocalizedStringKey(clearAllPending ? "receive_clear_history_title" : "receive_delete_history_title")),
+			isPresented: Binding(get: { model.state.historyDeleteTarget != nil }, set: { if !$0 { Task { @MainActor in model.dismissHistoryDelete() } } })
+		) {
+			Button(String(localized: "button_cancel"), role: .cancel, action: model.dismissHistoryDelete)
+			Button(String(localized: clearAllPending ? "receive_clear_history" : "button_delete_transfer"),
+				   role: .destructive, action: model.confirmHistoryDelete)
+		} message: {
+			historyDeleteMessage
+		}
+	}
+
+	private var history: some View {
+		List {
+			Section {
+				ForEach(transfers) { transfer in
+					ReceiveTransferRow(
+						transfer: transfer,
+						progress: progressForTransfer(events: model.coreState.events, transferId: transfer.transferId)
+					)
+					.swipeActions(edge: .trailing, allowsFullSwipe: true) {
+						if transfer.status.isTerminalReceiveHistory {
+							Button(role: .destructive) {
+								model.requestDeleteHistoryItem(transfer.transferId)
+							} label: {
+								Label(String(localized: "button_delete_transfer"), systemImage: "trash")
+							}
+						}
+					}
+				}
+			} header: {
+				Text(LocalizedStringKey("receive_history_title"))
+			} footer: {
+				Text(LocalizedStringKey("receive_new_subtitle"))
+			}
+		}
+	}
+
+	private var emptyState: some View {
+		EmptyStateView(
+			systemImage: "tray.and.arrow.down",
+			title: String(localized: "receive_empty_title"),
+			message: String(localized: "receive_empty_body")
+		) {
+			Button(action: model.openAcquisition) {
+				Label(String(localized: "button_receive_files"), systemImage: "plus")
+			}
+			.buttonStyle(.borderedProminent)
+			.controlSize(.large)
+		}
+	}
+
+	private var clearAllPending: Bool { model.state.historyDeleteTarget == .all }
+
+	@ViewBuilder
+	private var historyDeleteMessage: some View {
+		if let target = model.state.historyDeleteTarget {
+			if target == .all {
+				Text(LocalizedStringKey("receive_clear_history_description"))
+			} else {
+				Text(String(format: String(localized: "receive_delete_history_description"),
+							 transferName(for: target) ?? String(localized: "receive_unknown_transfer")))
+			}
+		}
+	}
+
+	private func transferName(for target: ReceiveHistoryDeleteTarget) -> String? {
+		if case .transfer(let id) = target {
+			return transfers.first { $0.transferId == id }?.transferName
+		}
+		return nil
+	}
+}
+
+private struct ReceiveTransferRow: View {
+	let transfer: Transfer
+	let progress: TransferProgress?
+
+	var body: some View {
+		HStack(spacing: 12) {
+			Image(systemName: "doc")
+				.foregroundStyle(.secondary)
+				.frame(width: 40, height: 40)
+				.background(.quaternary, in: RoundedRectangle(cornerRadius: 9))
+			VStack(alignment: .leading, spacing: 3) {
+				Text(transfer.transferName ?? String(localized: "receive_unknown_transfer"))
+					.font(.body).lineLimit(1)
+				Text("\(formatBytes(transfer.totalSize)) · \(statusLabel(transfer.status))")
+					.font(.caption).foregroundStyle(.secondary)
+				if transfer.status == .receiving, let progress {
+					ProgressRow(labelKey: progress.labelKey, progress: progress.progress, detail: progress.detail)
+						.padding(.top, 2)
+				}
+			}
+			Spacer(minLength: 0)
+		}
+	}
+}

apple/VniDrop/Features/Send/FilePreviewRepository.swift

@@ -0,0 +1,142 @@
+import Foundation
+import Combine
+
+/// Persisted per-transfer thumbnail store, ported from
+/// `feature/send/FilePreviewRepository.kt` + `PlatformPreviewStore.ios.kt`.
+/// Only small PNG/JPEG/WEBP previews are retained, under a total quota.
+struct PreviewStoragePolicy {
+	var maxEntryBytes: Int = 512 * 1024
+	var maxTotalBytes: Int64 = 20 * 1024 * 1024
+}
+
+private struct PreviewFileInfo {
+	let transferId: UInt64
+	let byteSize: Int64
+	let modifiedAtMillis: Int64
+}
+
+@MainActor
+final class FilePreviewRepository: ObservableObject {
+	@Published private(set) var previews: [UInt64: Data] = [:]
+
+	private let directory: String
+	private let policy: PreviewStoragePolicy
+	private let fm = FileManager.default
+
+	init(appDataDir: String, policy: PreviewStoragePolicy = PreviewStoragePolicy()) {
+		self.directory = (appDataDir as NSString).appendingPathComponent("ui/previews")
+		self.policy = policy
+	}
+
+	func restore(activeTransferIds: Set<UInt64>) {
+		let files = listFiles()
+		for file in files where !(activeTransferIds.contains(file.transferId)
+			&& (1...Int64(policy.maxEntryBytes)).contains(file.byteSize)) {
+			deleteFile(file.transferId)
+		}
+		enforceQuota()
+		var result: [UInt64: Data] = [:]
+		for file in listFiles() where activeTransferIds.contains(file.transferId) {
+			if let data = readFile(file.transferId), data.isSupportedPreview, data.count <= policy.maxEntryBytes {
+				result[file.transferId] = data
+			} else {
+				deleteFile(file.transferId)
+			}
+		}
+		previews = result
+	}
+
+	func save(transferId: UInt64, bytes: Data) {
+		guard (1...policy.maxEntryBytes).contains(bytes.count), bytes.isSupportedPreview else { return }
+		guard writeAtomically(transferId: transferId, bytes: bytes) else { return }
+		enforceQuota(protectedTransferId: transferId)
+		if readFile(transferId) != nil {
+			previews[transferId] = bytes
+		}
+	}
+
+	func remove(transferId: UInt64) {
+		deleteFile(transferId)
+		previews.removeValue(forKey: transferId)
+	}
+
+	// MARK: - Store (ported from IosPreviewStore)
+
+	private func enforceQuota(protectedTransferId: UInt64? = nil) {
+		let files = listFiles().sorted { $0.modifiedAtMillis < $1.modifiedAtMillis }
+		var total = files.reduce(Int64(0)) { $0 + $1.byteSize }
+		for file in files {
+			if total <= policy.maxTotalBytes { break }
+			if file.transferId == protectedTransferId { continue }
+			deleteFile(file.transferId)
+			total -= file.byteSize
+			previews.removeValue(forKey: file.transferId)
+		}
+	}
+
+	private func ensureDirectory() {
+		try? fm.createDirectory(atPath: directory, withIntermediateDirectories: true)
+	}
+
+	private func path(_ transferId: UInt64) -> String {
+		(directory as NSString).appendingPathComponent("\(transferId).preview")
+	}
+
+	private func listFiles() -> [PreviewFileInfo] {
+		ensureDirectory()
+		guard let names = try? fm.contentsOfDirectory(atPath: directory) else { return [] }
+		return names.compactMap { name in
+			guard name.hasSuffix(".preview"),
+				let id = UInt64(name.replacingOccurrences(of: ".preview", with: "")) else { return nil }
+			let full = (directory as NSString).appendingPathComponent(name)
+			guard let attrs = try? fm.attributesOfItem(atPath: full) else { return nil }
+			let size = (attrs[.size] as? NSNumber)?.int64Value ?? 0
+			let modified = ((attrs[.modificationDate] as? Date)?.timeIntervalSince1970 ?? 0) * 1000
+			return PreviewFileInfo(transferId: id, byteSize: size, modifiedAtMillis: Int64(modified))
+		}
+	}
+
+	private func readFile(_ transferId: UInt64) -> Data? {
+		try? Data(contentsOf: URL(fileURLWithPath: path(transferId)))
+	}
+
+	private func writeAtomically(transferId: UInt64, bytes: Data) -> Bool {
+		ensureDirectory()
+		if fm.fileExists(atPath: path(transferId)) { return true }
+		let temporary = (directory as NSString).appendingPathComponent(".\(transferId).tmp")
+		do {
+			try bytes.write(to: URL(fileURLWithPath: temporary), options: .atomic)
+		} catch {
+			return false
+		}
+		do {
+			if fm.fileExists(atPath: path(transferId)) {
+				try? fm.removeItem(atPath: temporary)
+				return true
+			}
+			try fm.moveItem(atPath: temporary, toPath: path(transferId))
+			return true
+		} catch {
+			try? fm.removeItem(atPath: temporary)
+			return false
+		}
+	}
+
+	private func deleteFile(_ transferId: UInt64) {
+		try? fm.removeItem(atPath: path(transferId))
+	}
+}
+
+extension Data {
+	/// Matches `isSupportedPreview()`: PNG / JPEG / WEBP magic bytes.
+	var isSupportedPreview: Bool {
+		let bytes = [UInt8](self)
+		let png = bytes.count >= 8 && bytes[0] == 0x89
+			&& bytes[1] == 0x50 && bytes[2] == 0x4E && bytes[3] == 0x47   // "PNG"
+		let jpeg = bytes.count >= 3 && bytes[0] == 0xFF && bytes[1] == 0xD8 && bytes[2] == 0xFF
+		let webp = bytes.count >= 12
+			&& bytes[0] == 0x52 && bytes[1] == 0x49 && bytes[2] == 0x46 && bytes[3] == 0x46   // "RIFF"
+			&& bytes[8] == 0x57 && bytes[9] == 0x45 && bytes[10] == 0x42 && bytes[11] == 0x50 // "WEBP"
+		return png || jpeg || webp
+	}
+}

apple/VniDrop/Features/Send/SendModel.swift

@@ -0,0 +1,285 @@
+import Foundation
+import Combine
+
+enum TransferDetailPanel: Equatable {
+	case activity
+	case receivers
+	case share
+}
+
+/// Which invitation delivery action produced a result (for success copy).
+enum InvitationAction {
+	case export
+	case share
+	case nfc
+}
+
+/// Send feature state, ported from `feature/send/SendViewModel.kt` (`SendState`).
+struct SendState: Equatable {
+	var isComposerOpen = false
+	var selectedFiles: [PickedShareFile] = []
+	var transferName = ""
+	var senderName = ""
+	var accessPolicy: ShareAccessPolicy = .requireApproval
+	var isSharing = false
+	var selectedTransferId: UInt64?
+	var transferThumbnails: [UInt64: Data] = [:]
+	var detailPanel: TransferDetailPanel?
+	var receiverHistory: [ReceiverRequestModel] = []
+	var isLoadingReceivers = false
+	var isDeleteConfirmationOpen = false
+	var isDeleting = false
+
+	func canCreateShare(coreInitialized: Bool) -> Bool {
+		coreInitialized && !selectedFiles.isEmpty && !transferName.isEmpty && !isSharing
+	}
+}
+
+@MainActor
+final class SendModel: ObservableObject {
+	@Published private(set) var state = SendState()
+	@Published private(set) var coreState = CoreState()
+
+	/// Requests a file/folder pick or clipboard copy, consumed by the view layer.
+	@Published var pendingFilePick = false
+	@Published var pendingFolderPick = false
+
+	private let repository: CoreRepository
+	private let fileSystemService: FileSystemService
+	private let filePreviewRepository: FilePreviewRepository
+	private let messages: UiMessageController
+	private var cancellables = Set<AnyCancellable>()
+
+	init(
+		repository: CoreRepository,
+		fileSystemService: FileSystemService,
+		preferences: AppPreferencesRepository,
+		filePreviewRepository: FilePreviewRepository,
+		messages: UiMessageController
+	) {
+		self.repository = repository
+		self.fileSystemService = fileSystemService
+		self.filePreviewRepository = filePreviewRepository
+		self.messages = messages
+
+		repository.$state.sink { [weak self] in self?.coreState = $0 }.store(in: &cancellables)
+
+		repository.signals
+			.sink { [weak self] signal in
+				guard let self else { return }
+				switch signal {
+				case .transfersChanged:
+					Task { _ = await self.repository.refresh() }
+				case .receiverHistoryChanged(let id), .approvalChanged(let id):
+					if id == self.state.selectedTransferId { self.refreshReceivers(id) }
+				}
+			}
+			.store(in: &cancellables)
+
+		filePreviewRepository.$previews
+			.sink { [weak self] previews in self?.state.transferThumbnails = previews }
+			.store(in: &cancellables)
+
+		repository.$state
+			.map { core -> Set<UInt64>? in
+				core.isInitialized ? Set(core.transfers.map(\.transferId)) : nil
+			}
+			.removeDuplicates()
+			.sink { [weak self] ids in
+				if let ids { self?.filePreviewRepository.restore(activeTransferIds: ids) }
+			}
+			.store(in: &cancellables)
+
+		preferences.$preferences
+			.sink { [weak self] prefs in
+				guard let self else { return }
+				if self.state.senderName.isEmpty { self.state.senderName = prefs.username }
+			}
+			.store(in: &cancellables)
+	}
+
+	// MARK: - Composer
+
+	func openComposer() {
+		if state.isSharing { return }
+		let discarded = state.selectedFiles
+		state.isComposerOpen = true
+		state.selectedFiles = []
+		state.transferName = ""
+		state.accessPolicy = .requireApproval
+		discardPickedFiles(discarded)
+	}
+
+	func dismissComposer() {
+		if state.isSharing { return }
+		let discarded = state.selectedFiles
+		state.isComposerOpen = false
+		state.selectedFiles = []
+		state.transferName = ""
+		state.accessPolicy = .requireApproval
+		discardPickedFiles(discarded)
+	}
+
+	func selectFile() { pendingFilePick = true }
+	func selectFolder() { pendingFolderPick = true }
+
+	func onFilesPicked(_ files: [PickedShareFile]) {
+		if files.isEmpty { return }
+		let selectedValues = Set(files.map(\.value))
+		let discarded = state.selectedFiles.filter { !selectedValues.contains($0.value) }
+		state.isComposerOpen = true
+		state.selectedFiles = files
+		state.transferName = defaultTransferName(files)
+		discardPickedFiles(discarded)
+	}
+
+	func onFilePickFailed(_ reason: String) {
+		messages.error(InvitationError.message(reason.isEmpty ? "selection failed" : reason))
+	}
+
+	func clearSelectedSource() {
+		let discarded = state.selectedFiles
+		state.selectedFiles = []
+		state.transferName = ""
+		discardPickedFiles(discarded)
+	}
+
+	func removeSelectedFile(_ value: String) {
+		let discarded = state.selectedFiles.filter { $0.value == value }
+		let remaining = state.selectedFiles.filter { $0.value != value }
+		let wasDefault = state.transferName == defaultTransferName(state.selectedFiles)
+		state.selectedFiles = remaining
+		state.transferName = remaining.isEmpty ? "" : (wasDefault ? defaultTransferName(remaining) : state.transferName)
+		discardPickedFiles(discarded)
+	}
+
+	func setTransferName(_ value: String) { state.transferName = value }
+	func setSenderName(_ value: String) { state.senderName = value }
+	func setAccessPolicy(_ value: ShareAccessPolicy) { state.accessPolicy = value }
+
+	// MARK: - Transfer detail
+
+	func openTransfer(_ transferId: UInt64) {
+		state.selectedTransferId = transferId
+		state.detailPanel = nil
+		refreshReceivers(transferId)
+	}
+
+	func closeTransferDetails() {
+		state.selectedTransferId = nil
+		state.detailPanel = nil
+		state.receiverHistory = []
+		state.isDeleteConfirmationOpen = false
+	}
+
+	func openActivity() { state.detailPanel = .activity }
+	func openShare() { state.detailPanel = .share }
+	func openReceivers() {
+		guard let id = state.selectedTransferId else { return }
+		state.detailPanel = .receivers
+		refreshReceivers(id)
+	}
+	func closeDetailPanel() { state.detailPanel = nil }
+
+	func requestDeleteTransfer() { state.isDeleteConfirmationOpen = true }
+	func dismissDeleteTransfer() { if !state.isDeleting { state.isDeleteConfirmationOpen = false } }
+
+	func confirmDeleteTransfer() {
+		guard let transferId = state.selectedTransferId, !state.isDeleting else { return }
+		state.isDeleting = true
+		Task {
+			let result = await repository.delete(transferId: transferId)
+			switch result {
+			case .success:
+				filePreviewRepository.remove(transferId: transferId)
+				state.selectedTransferId = nil
+				state.detailPanel = nil
+				state.receiverHistory = []
+				state.isDeleteConfirmationOpen = false
+				state.isDeleting = false
+				messages.tryShow(UiMessage(text: .resource("transfer_deleted"), tone: .success))
+			case .failure(let error):
+				state.isDeleting = false
+				messages.error(error)
+			}
+		}
+	}
+
+	// MARK: - Invitation results / share
+
+	func onInvitationResult(_ action: InvitationAction, _ result: Result<Void, Error>) {
+		switch result {
+		case .success:
+			let key: String?
+			switch action {
+			case .export: key = "transfer_invitation_saved"
+			case .nfc: key = "transfer_nfc_written"
+			case .share: key = nil  // system share sheet already confirms
+			}
+			if let key { messages.tryShow(UiMessage(text: .resource(key), tone: .success)) }
+		case .failure(let error):
+			messages.error(error)
+		}
+	}
+
+	func createShare() {
+		let current = state
+		if current.selectedFiles.isEmpty { return }
+		if !current.canCreateShare(coreInitialized: coreState.isInitialized) { return }
+		state.isSharing = true
+		Task {
+			let result = await fileSystemService.sharePickedFiles(
+				repository: repository,
+				files: current.selectedFiles,
+				transferName: current.transferName.trimmingCharacters(in: .whitespacesAndNewlines),
+				senderName: current.senderName.trimmingCharacters(in: .whitespacesAndNewlines),
+				accessPolicy: current.accessPolicy
+			)
+			switch result {
+			case .success(let share):
+				await fileSystemService.discardPickedFiles(current.selectedFiles)
+				if let thumb = current.selectedFiles.compactMap(\.thumbnailData).first {
+					filePreviewRepository.save(transferId: share.transferId, bytes: thumb)
+				}
+				state.isComposerOpen = false
+				state.selectedFiles = []
+				state.transferName = ""
+				state.accessPolicy = .requireApproval
+				state.isSharing = false
+				messages.show(UiMessage(text: .resource("send_transfer_created"), tone: .success))
+			case .failure(let error):
+				state.isSharing = false
+				messages.error(error)
+			}
+		}
+	}
+
+	// MARK: - Internals
+
+	private func defaultTransferName(_ files: [PickedShareFile]) -> String {
+		if files.isEmpty { return "" }
+		if files.count == 1 { return files[0].displayName }
+		if files.allSatisfy(\.isDirectory) { return "\(files.count) folders" }
+		return "\(files.count) files"
+	}
+
+	private func discardPickedFiles(_ files: [PickedShareFile]) {
+		if files.isEmpty { return }
+		Task { await fileSystemService.discardPickedFiles(files) }
+	}
+
+	private func refreshReceivers(_ transferId: UInt64) {
+		state.isLoadingReceivers = true
+		Task {
+			let result = await repository.receiverRequests(transferId: transferId)
+			switch result {
+			case .success(let requests):
+				state.receiverHistory = requests
+				state.isLoadingReceivers = false
+			case .failure(let error):
+				state.isLoadingReceivers = false
+				messages.error(error)
+			}
+		}
+	}
+}

apple/VniDrop/Features/Send/SendScreen.swift

@@ -0,0 +1,191 @@
+import SwiftUI
+
+/// Send screen, rebuilt on native SwiftUI. A grouped `List` of outgoing transfers,
+/// with the composer and detail panels as native sheets and delete as an alert.
+struct SendScreen: View {
+	@ObservedObject var model: SendModel
+	let windowClass: WindowClass
+
+	private var outgoing: [Transfer] {
+		model.coreState.transfers.filter { $0.direction == .send }
+	}
+	private var selectedTransfer: Transfer? {
+		guard let id = model.state.selectedTransferId else { return nil }
+		return outgoing.first { $0.transferId == id }
+	}
+
+	private var detailsBinding: Binding<Bool> {
+		Binding(get: { model.state.selectedTransferId != nil }, set: { if !$0 { model.closeTransferDetails() } })
+	}
+
+	var body: some View {
+		NavigationStack {
+			Group {
+				if outgoing.isEmpty {
+					ScrollView { emptyState }
+				} else {
+					catalog
+				}
+			}
+			.navigationTitle(Text(LocalizedStringKey("send_title")))
+			.toolbar {
+				ToolbarItem(placement: .primaryAction) {
+					Button(action: model.openComposer) {
+						Label(String(localized: "button_create_new_transfer"), systemImage: "plus")
+					}
+				}
+			}
+			.navigationDestination(isPresented: detailsBinding) {
+				if let transfer = selectedTransfer {
+					detailView(for: transfer)
+				}
+			}
+		}
+		.adaptiveDrawer(
+			isPresented: Binding(get: { model.state.isComposerOpen }, set: { _ in }),
+			windowClass: windowClass,
+			onDismiss: model.dismissComposer
+		) {
+			TransferComposer(model: model, windowClass: windowClass)
+		}
+	}
+
+	/// The pushed transfer details view, with its detail-panel sheet and delete
+	/// alert attached here so they present from the detail's own context (presenting
+	/// modals from the parent stack while a detail is pushed is unreliable on macOS).
+	private func detailView(for transfer: Transfer) -> some View {
+		TransferDetailsView(model: model, transfer: transfer, events: model.coreState.events)
+			.adaptiveDrawer(
+				isPresented: Binding(get: { model.state.detailPanel != nil }, set: { _ in }),
+				windowClass: windowClass,
+				onDismiss: model.closeDetailPanel
+			) {
+				if let panel = model.state.detailPanel {
+					DetailPanelContent(model: model, transfer: transfer, panel: panel)
+				}
+			}
+			.alert(
+				Text(LocalizedStringKey("transfer_delete_title")),
+				isPresented: Binding(get: { model.state.isDeleteConfirmationOpen }, set: { if !$0 { Task { @MainActor in model.dismissDeleteTransfer() } } })
+			) {
+				Button(String(localized: "button_cancel"), role: .cancel, action: model.dismissDeleteTransfer)
+				Button(String(localized: "button_delete_transfer"), role: .destructive, action: model.confirmDeleteTransfer)
+			} message: {
+				Text(String(format: String(localized: "transfer_delete_description"),
+							 transfer.transferName ?? String(localized: "send_new_transfer_title")))
+			}
+	}
+
+	private var catalog: some View {
+		List {
+			Section {
+				ForEach(outgoing) { transfer in
+					Button {
+						model.openTransfer(transfer.transferId)
+					} label: {
+						TransferListItem(
+							transfer: transfer,
+							thumbnail: model.state.transferThumbnails[transfer.transferId],
+							progress: progress(for: transfer)
+						)
+					}
+					.buttonStyle(.plain)
+				}
+			} header: {
+				Text(LocalizedStringKey("send_transfers_title"))
+			} footer: {
+				Text(LocalizedStringKey("send_subtitle"))
+			}
+		}
+	}
+
+	private var emptyState: some View {
+		EmptyStateView(
+			systemImage: "paperplane",
+			title: String(localized: "send_empty_title"),
+			message: String(localized: "send_empty_body")
+		) {
+			Button(action: model.openComposer) {
+				Label(String(localized: "button_create_new_transfer"), systemImage: "plus")
+			}
+			.buttonStyle(.borderedProminent)
+			.controlSize(.large)
+		}
+	}
+
+	private func progress(for transfer: Transfer) -> TransferProgress? {
+		switch transfer.status {
+		case .importing: return progressForTransfer(events: model.coreState.events, transferId: transfer.transferId)
+		case .sharing: return activeSendProgress(events: model.coreState.events, transferId: transfer.transferId, totalSizeHint: transfer.totalSize)
+		default: return nil
+		}
+	}
+}
+
+private struct TransferListItem: View {
+	let transfer: Transfer
+	let thumbnail: Data?
+	let progress: TransferProgress?
+
+	var body: some View {
+		HStack(spacing: 12) {
+			FileArtwork(thumbnail: thumbnail)
+				.frame(width: 40, height: 40)
+				.background(.quaternary, in: RoundedRectangle(cornerRadius: 9))
+			VStack(alignment: .leading, spacing: 3) {
+				HStack {
+					Text(transfer.transferName ?? String(localized: "send_new_transfer_title"))
+						.font(.body).lineLimit(1)
+					Spacer()
+					StatusPill(label: statusLabel(transfer.status), tone: transfer.status.pillTone)
+				}
+				Text("\(formatBytes(transfer.totalSize)) · \(accessPolicyLabel(transfer.accessPolicy))")
+					.font(.caption).foregroundStyle(.secondary).lineLimit(1)
+				if let progress, transfer.status == .importing || transfer.status == .sharing {
+					ProgressRow(labelKey: progress.labelKey, progress: progress.progress, detail: progress.detail)
+						.padding(.top, 2)
+				}
+			}
+			Image(systemName: "chevron.forward")
+				.font(.footnote.weight(.semibold)).foregroundStyle(.tertiary)
+		}
+		.contentShape(Rectangle())
+	}
+}
+
+struct FileArtwork: View {
+	let thumbnail: Data?
+
+	var body: some View {
+		if let thumbnail, let image = PlatformImage.from(data: thumbnail) {
+			image.resizable().aspectRatio(contentMode: .fill)
+				.clipShape(RoundedRectangle(cornerRadius: 8))
+		} else {
+			Image(systemName: "doc")
+				.font(.system(size: 18))
+				.foregroundStyle(.secondary)
+		}
+	}
+}
+
+func statusLabel(_ status: TransferStatus) -> String {
+	String(localized: String.LocalizationValue(statusLabelKey(status)))
+}
+
+func accessPolicyLabel(_ policy: ShareAccessPolicy) -> String {
+	switch policy {
+	case .requireApproval: return String(localized: "send_access_approval")
+	case .anyoneWithTransfer: return String(localized: "send_access_anyone")
+	}
+}
+
+extension TransferStatus {
+	var pillTone: PillTone {
+		switch self {
+		case .sharing, .done: return .brand
+		case .importing, .receiving: return .warning
+		case .failed, .cancelled: return .destructive
+		case .stopped: return .neutral
+		}
+	}
+}

apple/VniDrop/Features/Send/TransferComposer.swift

@@ -0,0 +1,169 @@
+import SwiftUI
+
+/// Transfer composer drawer, ported from `feature/send/TransferComposer.kt`.
+/// Two steps: choose files/folder, then review + name + access policy + share.
+struct TransferComposer: View {
+	@ObservedObject var model: SendModel
+	let windowClass: WindowClass
+
+	private var state: SendState { model.state }
+
+	var body: some View {
+		VStack(alignment: .leading, spacing: 16) {
+			if state.selectedFiles.isEmpty {
+				chooseStep
+			} else {
+				reviewStep
+			}
+		}
+		.padding(.horizontal, 20).padding(.vertical, 12)
+		.frame(maxWidth: .infinity, alignment: .leading)
+		.sendPickers(model: model)
+	}
+
+	private var chooseStep: some View {
+		VStack(alignment: .leading, spacing: 16) {
+			Text(LocalizedStringKey("send_choose_file_title")).font(.title2).fontWeight(.semibold)
+			Text(LocalizedStringKey("send_choose_file_body"))
+				.font(.subheadline).foregroundStyle(.secondary)
+			VStack(spacing: 14) {
+				Image(systemName: "doc").font(.system(size: 30)).foregroundStyle(.tint)
+				PrimaryButton(title: String(localized: "button_choose_files"), action: model.selectFile).fixedSize()
+				QuietButton(title: String(localized: "button_choose_folder"), action: model.selectFolder)
+			}
+			.frame(maxWidth: .infinity)
+			.padding(28)
+			.background(.quaternary.opacity(0.5), in: RoundedRectangle(cornerRadius: 16))
+		}
+	}
+
+	private var reviewStep: some View {
+		VStack(alignment: .leading, spacing: 16) {
+			Text(LocalizedStringKey("send_review_title")).font(.title2).fontWeight(.semibold)
+			if state.selectedFiles.count > 1 {
+				Text(String(format: String(localized: "send_selected_files_count"), state.selectedFiles.count))
+					.font(.subheadline).foregroundStyle(.secondary)
+			}
+			ForEach(state.selectedFiles) { file in
+				SelectedFileCard(
+					file: file,
+					canRemove: state.selectedFiles.count > 1 && !state.isSharing,
+					onRemove: { model.removeSelectedFile(file.value) }
+				)
+			}
+			Field(label: String(localized: "field_transfer_name"),
+				  value: Binding(get: { state.transferName }, set: model.setTransferName))
+			Field(label: String(localized: "field_sender_name"),
+				  value: Binding(get: { state.senderName }, set: model.setSenderName))
+			Text(LocalizedStringKey("send_access_title")).font(.headline)
+			PolicyOption(
+				icon: "checkmark.shield", titleKey: "send_access_approval", descKey: "send_access_approval_description",
+				selected: state.accessPolicy == .requireApproval,
+				onTap: { model.setAccessPolicy(.requireApproval) }
+			)
+			PolicyOption(
+				icon: "globe", titleKey: "send_access_anyone", descKey: "send_access_anyone_description",
+				selected: state.accessPolicy == .anyoneWithTransfer,
+				onTap: { model.setAccessPolicy(.anyoneWithTransfer) }
+			)
+			if state.accessPolicy == .anyoneWithTransfer {
+				Label(String(localized: "send_access_anyone_warning"), systemImage: "exclamationmark.triangle.fill")
+					.font(.caption).foregroundStyle(.orange)
+			}
+			actions
+		}
+	}
+
+	@ViewBuilder
+	private var actions: some View {
+		let shareTitle = state.isSharing
+			? String(localized: "button_sharing_file") : String(localized: "button_share_file")
+		let shareButton = PrimaryButton(
+			title: shareTitle, action: model.createShare,
+			enabled: state.canCreateShare(coreInitialized: model.coreState.isInitialized)
+		)
+		if windowClass == .phone {
+			VStack(spacing: 8) {
+				shareButton
+				QuietButton(title: String(localized: "button_change_files"), action: model.selectFile, enabled: !state.isSharing)
+				QuietButton(title: String(localized: "button_choose_folder"), action: model.selectFolder, enabled: !state.isSharing)
+			}
+		} else {
+			HStack(spacing: 8) {
+				shareButton.fixedSize()
+				QuietButton(title: String(localized: "button_change_files"), action: model.selectFile, enabled: !state.isSharing)
+				QuietButton(title: String(localized: "button_choose_folder"), action: model.selectFolder, enabled: !state.isSharing)
+				QuietButton(title: String(localized: "button_clear"), action: model.clearSelectedSource, enabled: !state.isSharing)
+			}
+		}
+	}
+}
+
+private struct SelectedFileCard: View {
+	let file: PickedShareFile
+	let canRemove: Bool
+	let onRemove: () -> Void
+
+	var body: some View {
+		HStack(spacing: 12) {
+			FileArtwork(thumbnail: file.thumbnailData)
+				.frame(width: 44, height: 44)
+				.background(.quaternary, in: RoundedRectangle(cornerRadius: 10))
+			VStack(alignment: .leading, spacing: 3) {
+				Text(file.displayName).lineLimit(1)
+				Text(subtitle).font(.caption).foregroundStyle(.secondary)
+			}
+			Spacer()
+			if canRemove {
+				Button(role: .destructive, action: onRemove) {
+					Image(systemName: "trash")
+				}
+				.buttonStyle(.borderless)
+				.tint(.red)
+			}
+		}
+		.padding(14)
+		.frame(maxWidth: .infinity)
+		.background(.quaternary.opacity(0.5), in: RoundedRectangle(cornerRadius: 14))
+	}
+
+	private var subtitle: String {
+		if file.isDirectory { return String(localized: "send_folder_label") }
+		if let size = file.sizeBytes { return formatBytes(size) }
+		return String(localized: "send_file_size_unknown")
+	}
+}
+
+private struct PolicyOption: View {
+	let icon: String
+	let titleKey: String
+	let descKey: String
+	let selected: Bool
+	let onTap: () -> Void
+
+	var body: some View {
+		Button(action: onTap) {
+			HStack(spacing: 12) {
+				Image(systemName: icon)
+					.font(.system(size: 20))
+					.foregroundStyle(selected ? AnyShapeStyle(.tint) : AnyShapeStyle(.secondary))
+					.frame(width: 22)
+				VStack(alignment: .leading, spacing: 3) {
+					Text(LocalizedStringKey(titleKey))
+					Text(LocalizedStringKey(descKey)).font(.caption).foregroundStyle(.secondary)
+				}
+				Spacer()
+				Image(systemName: selected ? "checkmark.circle.fill" : "circle")
+					.foregroundStyle(selected ? AnyShapeStyle(.tint) : AnyShapeStyle(.tertiary))
+			}
+			.padding(14)
+			.frame(maxWidth: .infinity)
+			.background(.quaternary.opacity(selected ? 0.8 : 0.4), in: RoundedRectangle(cornerRadius: 14))
+			.overlay(
+				RoundedRectangle(cornerRadius: 14)
+					.stroke(selected ? AnyShapeStyle(.tint) : AnyShapeStyle(.clear), lineWidth: 1.5)
+			)
+		}
+		.buttonStyle(.plain)
+	}
+}

apple/VniDrop/Features/Send/TransferDetailsView.swift

@@ -0,0 +1,328 @@
+import SwiftUI
+import CoreImage.CIFilterBuiltins
+
+/// Transfer details + drawer panels, ported from `feature/send/TransferDetails.kt`.
+
+struct TransferDetailsView: View {
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+	let events: [CoreEventModel]
+
+	private var pendingReceivers: Int {
+		model.state.receiverHistory.filter { $0.status == .requested || $0.status == .accepted }.count
+	}
+	private var completedReceivers: Int {
+		model.state.receiverHistory.filter { $0.status == .completed }.count
+	}
+
+	var body: some View {
+		Form {
+			Section {
+				LabeledContent(String(localized: "metadata_status"), value: statusLabel(transfer.status))
+				LabeledContent(String(localized: "metadata_size"), value: formatBytes(transfer.totalSize))
+				LabeledContent(String(localized: "send_access_title"), value: accessPolicyLabel(transfer.accessPolicy))
+			} header: {
+				Text(transfer.transferName ?? String(localized: "send_new_transfer_title"))
+			}
+
+			Section {
+				DetailDestination(
+					title: String(localized: "transfer_activity_title"),
+					description: String(localized: "transfer_activity_description"),
+					count: events.filter { $0.transferId == transfer.transferId && $0.isMeaningfulActivity }.count,
+					onTap: model.openActivity
+				)
+				DetailDestination(
+					title: String(localized: "transfer_receivers_title"),
+					description: receiversDescription(pendingReceivers, completedReceivers),
+					count: pendingReceivers + completedReceivers,
+					onTap: model.openReceivers
+				)
+				DetailDestination(
+					title: String(localized: "transfer_share_title"),
+					description: String(localized: "transfer_share_description"),
+					count: 0,
+					onTap: model.openShare
+				)
+			}
+		}
+		.formStyle(.grouped)
+		.navigationTitle(Text(LocalizedStringKey("send_transfer_details_title")))
+		#if os(iOS)
+		.navigationBarTitleDisplayMode(.inline)
+		#endif
+		.toolbar {
+			ToolbarItem(placement: .primaryAction) {
+				Button(role: .destructive, action: model.requestDeleteTransfer) {
+					Image(systemName: "trash")
+				}
+			}
+		}
+	}
+}
+
+private func receiversDescription(_ pending: Int, _ completed: Int) -> String {
+	if pending > 0 && completed > 0 {
+		return "\(String(format: String(localized: "transfer_receivers_pending"), pending)) · \(String(format: String(localized: "transfer_receivers_completed_count"), completed))"
+	}
+	if pending > 0 { return String(format: String(localized: "transfer_receivers_pending"), pending) }
+	if completed > 0 { return String(format: String(localized: "transfer_receivers_completed_count"), completed) }
+	return String(localized: "transfer_receivers_description")
+}
+
+private struct DetailDestination: View {
+	let title: String
+	let description: String
+	let count: Int
+	let onTap: () -> Void
+	var body: some View {
+		Button(action: onTap) {
+			HStack {
+				VStack(alignment: .leading, spacing: 3) {
+					Text(title).foregroundStyle(.primary)
+					Text(description).font(.caption).foregroundStyle(.secondary)
+				}
+				Spacer()
+				if count > 0 {
+					Text("\(count)")
+						.font(.footnote)
+						.foregroundStyle(.secondary)
+				}
+				Image(systemName: "chevron.forward")
+					.font(.footnote.weight(.semibold)).foregroundStyle(.tertiary)
+			}
+			.contentShape(Rectangle())
+		}
+		.buttonStyle(.plain)
+	}
+}
+
+// MARK: - Detail panels
+
+struct DetailPanelContent: View {
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+	let panel: TransferDetailPanel
+
+	var body: some View {
+		switch panel {
+		case .activity:
+			TransferActivityPanel(events: model.coreState.events, transferId: transfer.transferId)
+		case .receivers:
+			ReceiverHistoryPanel(
+				receivers: model.state.receiverHistory,
+				loading: model.state.isLoadingReceivers,
+				events: model.coreState.events,
+				transferTotalSize: transfer.totalSize
+			)
+		case .share:
+			TransferSharePanel(model: model, transfer: transfer)
+		}
+	}
+}
+
+private struct PanelContainer<Content: View>: View {
+	let title: String
+	@ViewBuilder let content: () -> Content
+	var body: some View {
+		VStack(alignment: .leading, spacing: 14) {
+			Text(title).font(VniType.titleLarge)
+			content()
+		}
+		.padding(.horizontal, 20).padding(.vertical, 14)
+		.frame(maxWidth: .infinity, alignment: .leading)
+	}
+}
+
+struct TransferActivityPanel: View {
+	@Environment(\.vniColors) private var colors
+	let events: [CoreEventModel]
+	let transferId: UInt64
+
+	var body: some View {
+		let visible = events
+			.filter { $0.transferId == transferId && $0.isMeaningfulActivity }
+			.sorted { $0.timestamp > $1.timestamp }
+		PanelContainer(title: String(localized: "transfer_activity_title")) {
+			if visible.isEmpty {
+				Text(LocalizedStringKey("transfer_no_activity")).foregroundStyle(colors.foregroundLighter)
+			} else {
+				ForEach(Array(visible.enumerated()), id: \.offset) { index, event in
+					if index > 0 { Divider().overlay(colors.borderDefault) }
+					Text(LocalizedStringKey(event.activityTitleKey))
+						.fontWeight(.medium).padding(.vertical, 14)
+				}
+			}
+		}
+	}
+}
+
+struct ReceiverHistoryPanel: View {
+	@Environment(\.vniColors) private var colors
+	let receivers: [ReceiverRequestModel]
+	let loading: Bool
+	let events: [CoreEventModel]
+	let transferTotalSize: UInt64
+
+	var body: some View {
+		PanelContainer(title: String(localized: "transfer_receivers_title")) {
+			if loading {
+				ProgressView().frame(maxWidth: .infinity).padding(40)
+			} else if receivers.isEmpty {
+				Text(LocalizedStringKey("transfer_no_receivers")).foregroundStyle(colors.foregroundLighter)
+			} else {
+				ForEach(Array(receivers.enumerated()), id: \.element.id) { index, receiver in
+					if index > 0 { Divider().overlay(colors.borderDefault) }
+					ReceiverRow(receiver: receiver, sendProgress: sendProgress(for: receiver))
+				}
+			}
+		}
+	}
+
+	private func sendProgress(for receiver: ReceiverRequestModel) -> TransferProgress? {
+		switch receiver.status {
+		case .accepted, .requested:
+			return progressForReceiver(events: events, transferId: receiver.transferId,
+									   remoteEndpointId: receiver.remoteEndpointId, totalSizeHint: transferTotalSize)
+		default: return nil
+		}
+	}
+}
+
+private struct ReceiverRow: View {
+	@Environment(\.vniColors) private var colors
+	let receiver: ReceiverRequestModel
+	let sendProgress: TransferProgress?
+
+	var body: some View {
+		let name = receiver.receiverName ?? receiver.receiverDeviceName ?? String(localized: "transfer_nearby_device")
+		let showLive = sendProgress != nil && receiver.status != .completed
+			&& receiver.status != .refused && receiver.status != .expired
+		VStack(alignment: .leading, spacing: 6) {
+			Text(name).font(VniType.bodyLarge).lineLimit(1)
+			if let deviceName = receiver.receiverDeviceName, deviceName != name {
+				Text(deviceName).font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+			}
+			if showLive, let sendProgress {
+				ProgressRow(labelKey: sendProgress.labelKey, progress: sendProgress.progress, detail: sendProgress.detail)
+			} else {
+				Text(LocalizedStringKey(receiver.status.statusTextKey))
+					.font(VniType.bodySmall).fontWeight(.medium)
+					.foregroundStyle(receiver.status.statusColor(colors))
+			}
+			if let reason = receiver.reason, !reason.isEmpty {
+				Text(reason).font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+			}
+		}
+		.frame(maxWidth: .infinity, alignment: .leading)
+		.padding(.vertical, 13)
+	}
+}
+
+struct TransferSharePanel: View {
+	@Environment(\.vniColors) private var colors
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+
+	var body: some View {
+		PanelContainer(title: String(localized: "transfer_share_title")) {
+			if let ticket = transfer.ticket {
+				qrCard(ticket: ticket)
+				Text(LocalizedStringKey("transfer_scan_qr"))
+					.font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+					.frame(maxWidth: .infinity)
+				ShareActionsView(model: model, transfer: transfer, ticket: ticket)
+			} else {
+				Text(LocalizedStringKey("transfer_event_preparing")).foregroundStyle(colors.foregroundLighter)
+			}
+		}
+	}
+
+	private func qrCard(ticket: String) -> some View {
+		ZStack {
+			if let qr = QRCode.generate(from: ticket) {
+				qr.interpolation(.none).resizable().scaledToFit().padding(14)
+			} else {
+				ProgressView()
+			}
+		}
+		.frame(width: 268, height: 268)
+		.background(Color.white, in: RoundedRectangle(cornerRadius: 18))
+		.frame(maxWidth: .infinity)
+	}
+}
+
+// MARK: - QR generation (CoreImage)
+
+enum QRCode {
+	static func generate(from string: String) -> Image? {
+		let context = CIContext()
+		let filter = CIFilter.qrCodeGenerator()
+		filter.message = Data(string.utf8)
+		filter.correctionLevel = "M"
+		guard let output = filter.outputImage else { return nil }
+		let scaled = output.transformed(by: CGAffineTransform(scaleX: 10, y: 10))
+		guard let cgImage = context.createCGImage(scaled, from: scaled.extent) else { return nil }
+		#if os(iOS)
+		return Image(uiImage: UIImage(cgImage: cgImage))
+		#else
+		return Image(nsImage: NSImage(cgImage: cgImage, size: .zero))
+		#endif
+	}
+}
+
+// MARK: - Event helpers (ported from TransferDetails.kt)
+
+extension CoreEventModel {
+	var isMeaningfulActivity: Bool {
+		(phase == "import" && kind == "started")
+			|| (phase == "ticket" && kind == "created")
+			|| (phase == "network" && (kind == "connecting" || kind == "connected"))
+			|| (phase == "download" && kind == "found-collection")
+			|| (phase == "lifecycle" && ["done", "cancelled", "share-stopped"].contains(kind))
+			|| ["receiver-requested", "receiver-accepted", "receiver-auto-approved",
+				"receiver-refused", "receiver-completed", "share-stopped", "failed"].contains(kind)
+	}
+
+	var activityTitleKey: String {
+		if phase == "import" && kind == "started" { return "transfer_event_preparing" }
+		if phase == "ticket" && kind == "created" { return "transfer_event_ready" }
+		if phase == "network" { return "transfer_event_connecting" }
+		if phase == "download" { return "transfer_event_downloading" }
+		if phase == "export" { return "transfer_event_saving" }
+		if kind == "receiver-requested" { return "transfer_event_requested" }
+		if kind == "receiver-accepted" || kind == "receiver-auto-approved" { return "transfer_event_approved" }
+		if kind == "receiver-refused" { return "transfer_event_refused" }
+		if kind == "receiver-completed" { return "transfer_event_completed" }
+		if kind == "share-stopped" || (phase == "lifecycle" && kind == "cancelled") { return "transfer_event_stopped" }
+		if kind == "failed" { return "transfer_event_failed" }
+		return "transfer_event_updated"
+	}
+}
+
+extension ReceiverDeliveryStatus {
+	var statusTextKey: String {
+		switch self {
+		case .requested: return "transfer_receiver_requested"
+		case .accepted: return "transfer_receiver_accepted"
+		case .refused: return "transfer_receiver_refused"
+		case .expired: return "transfer_receiver_expired"
+		case .completed: return "transfer_receiver_completed"
+		case .unknown: return "transfer_receiver_unknown"
+		}
+	}
+
+	func statusColor(_ colors: VniDropColors) -> Color {
+		switch self {
+		case .completed: return colors.brandDefault
+		case .refused, .expired: return colors.destructiveDefault
+		default: return colors.foregroundLighter
+		}
+	}
+}
+
+#if os(iOS)
+import UIKit
+#else
+import AppKit
+#endif

apple/VniDrop/Features/Send/TransferShareActions.swift

@@ -0,0 +1,61 @@
+import SwiftUI
+
+enum NfcShareAvailability { case available, unavailable, hidden }
+
+/// Invitation delivery actions, ported from `TransferShareActions` (iosMain).
+/// Platform implementations perform export, native share, and NFC write.
+@MainActor
+protocol TransferShareActions: AnyObject {
+	var canUseNativeShare: Bool { get }
+	var nfcAvailability: NfcShareAvailability { get }
+
+	func exportInvitation(ticket: String, transferName: String, onResult: @escaping (Result<Void, Error>) -> Void)
+	func shareInvitation(ticket: String, transferName: String, onResult: @escaping (Result<Void, Error>) -> Void)
+	func writeInvitationToNfc(ticket: String, onResult: @escaping (Result<Void, Error>) -> Void)
+	func cancelNfcWrite()
+}
+
+/// The QR + delivery buttons for a transfer's share panel, ported from the button
+/// stack in `TransferSharePanel` (`TransferDetails.kt`).
+struct ShareActionsView: View {
+	@Environment(\.vniColors) private var colors
+	@ObservedObject var model: SendModel
+	let transfer: Transfer
+	let ticket: String
+
+	@State private var actions: TransferShareActions = makePlatformShareActions()
+	@State private var writingNfc = false
+
+	var body: some View {
+		VStack(spacing: 12) {
+			if actions.nfcAvailability != .hidden {
+				SecondaryButton(
+					title: writingNfc ? String(localized: "transfer_nfc_waiting") : String(localized: "button_write_nfc"),
+					action: {
+						writingNfc = true
+						actions.writeInvitationToNfc(ticket: ticket) { result in
+							writingNfc = false
+							model.onInvitationResult(.nfc, result)
+						}
+					},
+					enabled: actions.nfcAvailability == .available && !writingNfc
+				)
+				if actions.nfcAvailability == .unavailable {
+					Text(LocalizedStringKey("transfer_nfc_unavailable"))
+						.font(VniType.bodySmall).foregroundStyle(colors.foregroundLighter)
+				}
+			}
+			SecondaryButton(title: String(localized: "button_download_invitation"), action: {
+				actions.exportInvitation(ticket: ticket, transferName: transfer.transferName ?? "") {
+					model.onInvitationResult(.export, $0)
+				}
+			})
+			PrimaryButton(title: String(localized: "button_native_share"), action: {
+				actions.shareInvitation(ticket: ticket, transferName: transfer.transferName ?? "") {
+					model.onInvitationResult(.share, $0)
+				}
+			}, enabled: actions.canUseNativeShare)
+		}
+		.onDisappear { actions.cancelNfcWrite() }
+	}
+}

apple/VniDrop/Features/Settings/BugReportService.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+/// Bug-report draft, ported from `diagnostics/BugReportService.kt`.
+struct BugReportDraft {
+	let whatHappened: String
+	let expected: String
+	let steps: String
+	let contact: String
+	let includeLogs: Bool
+}
+
+/// Bug-report submission. The full diagnostics transport (URLSession + build
+/// config) lands in the diagnostics phase; this protocol is the stable seam.
+protocol BugReportService {
+	func submit(_ draft: BugReportDraft, deviceInfo: DeviceInfo?) async -> Result<Void, Error>
+	func previewLogBytes() async -> Int
+}
+
+/// Offline-safe no-op used until the diagnostics transport is configured.
+struct NoopBugReportService: BugReportService {
+	func submit(_ draft: BugReportDraft, deviceInfo: DeviceInfo?) async -> Result<Void, Error> {
+		.failure(InvitationError.message("Bug reporting is not configured"))
+	}
+	func previewLogBytes() async -> Int { 0 }
+}
+
+/// Whether the diagnostics stack is compiled in (mirrors DiagnosticsBuildConfig).
+enum DiagnosticsBuildConfig {
+	static let included = false
+}

apple/VniDrop/Features/Settings/SettingsModel.swift

@@ -0,0 +1,288 @@
+import Foundation
+import Combine
+
+/// Settings sections, ported from `feature/settings/SettingsViewModel.kt`.
+enum SettingsSection: Hashable {
+	case overview
+	case preferences
+	case appearance
+	case notifications
+	case about
+	case bugReport
+
+	var titleKey: String {
+		switch self {
+		case .overview: return "settings_title"
+		case .preferences: return "preferences_title"
+		case .appearance: return "appearance_title"
+		case .notifications: return "notifications_title"
+		case .about: return "about_title"
+		case .bugReport: return "about_bug_report"
+		}
+	}
+}
+
+struct SettingsState: Equatable {
+	var selectedSection: SettingsSection = .overview
+	var username = ""
+	var receiveFolder: ReceiveFolder?
+	var folderAccessStatus: FolderAccessStatus = .unavailable
+	var isValidatingFolder = false
+	var supportsCustomReceiveFolders = true
+	var themeMode: ThemeMode = .system
+	var notificationsEnabled = false
+	var notificationPermission: NotificationPermission = .notDetermined
+	var diagnosticsEnabled = false
+	var deviceInfo: DeviceInfo?
+	var appVersion = ""
+	var isLoadingDeviceInfo = false
+	var bugWhatHappened = ""
+	var bugExpected = ""
+	var bugSteps = ""
+	var bugContact = ""
+	var bugIncludeLogs = true
+	var isSubmittingBugReport = false
+	var bugLogPreviewBytes = 0
+
+	static func == (lhs: SettingsState, rhs: SettingsState) -> Bool {
+		lhs.selectedSection == rhs.selectedSection && lhs.username == rhs.username
+			&& lhs.receiveFolder == rhs.receiveFolder && lhs.folderAccessStatus == rhs.folderAccessStatus
+			&& lhs.isValidatingFolder == rhs.isValidatingFolder
+			&& lhs.supportsCustomReceiveFolders == rhs.supportsCustomReceiveFolders
+			&& lhs.themeMode == rhs.themeMode && lhs.notificationsEnabled == rhs.notificationsEnabled
+			&& lhs.notificationPermission == rhs.notificationPermission
+			&& lhs.diagnosticsEnabled == rhs.diagnosticsEnabled && lhs.appVersion == rhs.appVersion
+			&& lhs.isLoadingDeviceInfo == rhs.isLoadingDeviceInfo
+			&& lhs.bugWhatHappened == rhs.bugWhatHappened && lhs.bugExpected == rhs.bugExpected
+			&& lhs.bugSteps == rhs.bugSteps && lhs.bugContact == rhs.bugContact
+			&& lhs.bugIncludeLogs == rhs.bugIncludeLogs && lhs.isSubmittingBugReport == rhs.isSubmittingBugReport
+			&& lhs.bugLogPreviewBytes == rhs.bugLogPreviewBytes
+			&& lhs.deviceInfo?.operatingSystem == rhs.deviceInfo?.operatingSystem
+	}
+}
+
+@MainActor
+final class SettingsModel: ObservableObject {
+	@Published private(set) var state: SettingsState
+	/// Set by the view to request the receive-folder picker (macOS).
+	@Published var pendingReceiveFolderPick = false
+
+	private let environment: PlatformEnvironment
+	private let deviceInfoProvider: DeviceInfoProvider
+	private let fileSystemService: FileSystemService
+	private let preferences: AppPreferencesRepository
+	private let notifications: LocalNotificationService
+	private let messages: UiMessageController
+	private let bugReports: BugReportService
+	private let diagnosticsIncluded: Bool
+
+	private var enableNotificationsAfterSettings = false
+	private var usernamePersistTask: Task<Void, Never>?
+	private var hasLocalUsernameDraft = false
+	private var cancellables = Set<AnyCancellable>()
+
+	init(
+		environment: PlatformEnvironment,
+		deviceInfoProvider: DeviceInfoProvider,
+		fileSystemService: FileSystemService,
+		preferences: AppPreferencesRepository,
+		notifications: LocalNotificationService,
+		messages: UiMessageController,
+		bugReports: BugReportService,
+		diagnosticsIncluded: Bool = DiagnosticsBuildConfig.included
+	) {
+		self.environment = environment
+		self.deviceInfoProvider = deviceInfoProvider
+		self.fileSystemService = fileSystemService
+		self.preferences = preferences
+		self.notifications = notifications
+		self.messages = messages
+		self.bugReports = bugReports
+		self.diagnosticsIncluded = diagnosticsIncluded
+		self.state = SettingsState(
+			supportsCustomReceiveFolders: fileSystemService.supportsCustomReceiveFolders,
+			appVersion: environment.appVersion
+		)
+
+		preferences.$preferences
+			.sink { [weak self] prefs in
+				guard let self else { return }
+				let previousFolder = self.state.receiveFolder
+				let folder = self.fileSystemService.effectiveReceiveFolder(prefs.receiveFolder)
+				self.state.username = self.hasLocalUsernameDraft ? self.state.username : prefs.username
+				self.state.receiveFolder = folder
+				self.state.themeMode = prefs.themeMode
+				self.state.notificationsEnabled = prefs.notificationsEnabled
+				self.state.diagnosticsEnabled = prefs.diagnosticsEnabled
+				if folder != previousFolder { Task { await self.validateFolder(folder) } }
+			}
+			.store(in: &cancellables)
+
+		refreshNotificationPermission()
+		loadDeviceInfo()
+	}
+
+	func selectSection(_ section: SettingsSection) {
+		state.selectedSection = section
+		if section == .about || section == .bugReport {
+			loadDeviceInfo()
+			if section == .bugReport { refreshBugLogPreview() }
+		}
+	}
+
+	func setUsername(_ value: String) {
+		hasLocalUsernameDraft = true
+		state.username = value
+		usernamePersistTask?.cancel()
+		usernamePersistTask = Task {
+			try? await Task.sleep(nanoseconds: 350_000_000)
+			if Task.isCancelled { return }
+			preferences.setUsername(value)
+		}
+	}
+
+	func setThemeMode(_ mode: ThemeMode) { preferences.setThemeMode(mode) }
+
+	func chooseReceiveFolder() {
+		if !fileSystemService.supportsCustomReceiveFolders { return }
+		pendingReceiveFolderPick = true
+	}
+
+	func onReceiveFolderPicked(_ folder: ReceiveFolder) { preferences.setReceiveFolder(folder) }
+	func onReceiveFolderPickFailed(_ reason: String) { messages.error(InvitationError.message(reason)) }
+	func resetReceiveFolder() { preferences.resetReceiveFolder() }
+
+	func setNotificationsEnabled(_ enabled: Bool) {
+		Task {
+			if !enabled {
+				preferences.setNotificationsEnabled(false)
+				notifications.cancelAll()
+				return
+			}
+			let permission = await notifications.requestPermission()
+			state.notificationPermission = permission
+			if permission == .granted {
+				await enableNotifications()
+			} else {
+				preferences.setNotificationsEnabled(false)
+				let key = permission == .unsupported ? "notifications_unsupported" : "notifications_permission_denied"
+				messages.show(UiMessage(
+					text: .resource(key),
+					tone: .warning,
+					actionLabel: permission == .denied ? .resource("button_open_settings") : nil,
+					onAction: permission == .denied ? { [weak self] in self?.openNotificationSettings() } : nil
+				))
+			}
+		}
+	}
+
+	func setDiagnosticsEnabled(_ enabled: Bool) {
+		if !diagnosticsIncluded { return }
+		Task {
+			preferences.setDiagnosticsEnabled(enabled)
+			messages.show(UiMessage(
+				text: .resource(enabled ? "diagnostics_enabled_message" : "diagnostics_disabled_message"),
+				tone: .success
+			))
+		}
+	}
+
+	func setBugWhatHappened(_ value: String) { state.bugWhatHappened = value }
+	func setBugExpected(_ value: String) { state.bugExpected = value }
+	func setBugSteps(_ value: String) { state.bugSteps = value }
+	func setBugContact(_ value: String) { state.bugContact = value }
+	func setBugIncludeLogs(_ value: Bool) { state.bugIncludeLogs = value }
+
+	func submitBugReport() {
+		if state.isSubmittingBugReport { return }
+		Task {
+			let snapshot = state
+			let what = snapshot.bugWhatHappened.trimmingCharacters(in: .whitespacesAndNewlines)
+			let expected = snapshot.bugExpected.trimmingCharacters(in: .whitespacesAndNewlines)
+			if what.isEmpty {
+				messages.show(UiMessage(text: .resource("bug_report_missing_what"), tone: .warning))
+				return
+			}
+			if expected.isEmpty {
+				messages.show(UiMessage(text: .resource("bug_report_missing_expected"), tone: .warning))
+				return
+			}
+			state.isSubmittingBugReport = true
+			let result = await bugReports.submit(
+				BugReportDraft(
+					whatHappened: what, expected: expected, steps: snapshot.bugSteps,
+					contact: snapshot.bugContact, includeLogs: snapshot.bugIncludeLogs
+				),
+				deviceInfo: snapshot.deviceInfo
+			)
+			switch result {
+			case .success:
+				state.isSubmittingBugReport = false
+				state.bugWhatHappened = ""
+				state.bugExpected = ""
+				state.bugSteps = ""
+				state.bugContact = ""
+				state.bugIncludeLogs = true
+				messages.show(UiMessage(text: .resource("bug_report_submitted"), tone: .success))
+				selectSection(.about)
+			case .failure:
+				state.isSubmittingBugReport = false
+				messages.show(UiMessage(text: .resource("bug_report_submit_failed"), tone: .error))
+			}
+		}
+	}
+
+	func openNotificationSettings() {
+		Task {
+			enableNotificationsAfterSettings = true
+			let result = await notifications.openSettings()
+			if case .failure = result {
+				enableNotificationsAfterSettings = false
+				messages.show(UiMessage(text: .resource("notifications_settings_open_failed"), tone: .error))
+			}
+		}
+	}
+
+	func refreshNotificationPermission() {
+		Task {
+			let permission = await notifications.refreshPermission()
+			state.notificationPermission = permission
+			if enableNotificationsAfterSettings {
+				enableNotificationsAfterSettings = false
+				if permission == .granted { await enableNotifications() }
+			} else if permission != .granted && state.notificationsEnabled {
+				preferences.setNotificationsEnabled(false)
+				notifications.cancelAll()
+			}
+		}
+	}
+
+	private func enableNotifications() async {
+		preferences.setNotificationsEnabled(true)
+		messages.show(UiMessage(text: .resource("notifications_enabled_message"), tone: .success))
+	}
+
+	private func loadDeviceInfo() {
+		if state.isLoadingDeviceInfo { return }
+		state.isLoadingDeviceInfo = true
+		Task {
+			let info = await deviceInfoProvider.load()
+			state.deviceInfo = info
+			state.isLoadingDeviceInfo = false
+		}
+	}
+
+	private func refreshBugLogPreview() {
+		Task {
+			let bytes = await bugReports.previewLogBytes()
+			state.bugLogPreviewBytes = bytes
+		}
+	}
+
+	private func validateFolder(_ folder: ReceiveFolder) async {
+		state.isValidatingFolder = true
+		let status = await fileSystemService.validateReceiveFolder(folder)
+		state.folderAccessStatus = status
+		state.isValidatingFolder = false
+	}
+}

apple/VniDrop/Features/Settings/SettingsScreen.swift

@@ -0,0 +1,105 @@
+import SwiftUI
+
+/// Settings screen, rebuilt on a native `Form` with `NavigationStack` push
+/// navigation. The model stays the source of truth via a derived path binding.
+struct SettingsScreen: View {
+	@ObservedObject var model: SettingsModel
+	let windowClass: WindowClass
+
+	private var path: Binding<[SettingsSection]> {
+		Binding(
+			get: {
+				switch model.state.selectedSection {
+				case .overview: return []
+				case .bugReport: return [.about, .bugReport]
+				case let section: return [section]
+				}
+			},
+			set: { newPath in model.selectSection(newPath.last ?? .overview) }
+		)
+	}
+
+	var body: some View {
+		NavigationStack(path: path) {
+			Form {
+				Section {
+					NavigationLink(value: SettingsSection.preferences) {
+						SettingsRow(icon: "person.crop.circle", title: String(localized: "preferences_title"), value: model.state.username)
+					}
+					NavigationLink(value: SettingsSection.appearance) {
+						SettingsRow(icon: "sun.max", title: String(localized: "appearance_title"), value: themeModeLabel(model.state.themeMode))
+					}
+				}
+				Section {
+					NavigationLink(value: SettingsSection.notifications) {
+						SettingsRow(icon: "bell", title: String(localized: "notifications_title"), value: nil)
+					}
+					NavigationLink(value: SettingsSection.about) {
+						SettingsRow(icon: "info.circle", title: String(localized: "about_title"), value: nil)
+					}
+				}
+			}
+			.formStyle(.grouped)
+			.navigationTitle(Text(LocalizedStringKey("settings_title")))
+			.navigationDestination(for: SettingsSection.self) { section in
+				Form {
+					SettingsSectionContent(model: model, section: section)
+				}
+				.formStyle(.grouped)
+				.navigationTitle(Text(LocalizedStringKey(section.titleKey)))
+				#if os(iOS)
+				.navigationBarTitleDisplayMode(.inline)
+				#endif
+			}
+		}
+	}
+}
+
+private struct SettingsSectionContent: View {
+	@ObservedObject var model: SettingsModel
+	let section: SettingsSection
+
+	var body: some View {
+		switch section {
+		case .overview:
+			EmptyView()
+		case .preferences:
+			PreferencesSettings(model: model)
+		case .appearance:
+			AppearanceSettings(model: model)
+		case .notifications:
+			NotificationSettings(model: model)
+		case .about:
+			AboutSettings(model: model)
+		case .bugReport:
+			BugReportSettings(model: model)
+		}
+	}
+}
+
+struct SettingsRow: View {
+	let icon: String
+	let title: String
+	let value: String?
+
+	var body: some View {
+		HStack(spacing: 12) {
+			Image(systemName: icon)
+				.foregroundStyle(.tint)
+				.frame(width: 26)
+			Text(title).foregroundStyle(.primary)
+			Spacer()
+			if let value {
+				Text(value).foregroundStyle(.secondary).lineLimit(1)
+			}
+		}
+	}
+}
+
+func themeModeLabel(_ mode: ThemeMode) -> String {
+	switch mode {
+	case .system: return String(localized: "appearance_system_mode")
+	case .light: return String(localized: "appearance_light_mode")
+	case .dark: return String(localized: "appearance_dark_mode")
+	}
+}

apple/VniDrop/Features/Settings/SettingsSections.swift

@@ -0,0 +1,123 @@
+import SwiftUI
+
+/// Settings section detail views, rebuilt as native `Form` content. Each view is
+/// placed inside a parent `Form`, so it returns `Section`s / rows directly.
+
+struct PreferencesSettings: View {
+	@ObservedObject var model: SettingsModel
+
+	var body: some View {
+		Section(String(localized: "field_username")) {
+			TextField(String(localized: "field_username"),
+					  text: Binding(get: { model.state.username }, set: model.setUsername))
+		}
+		if model.state.supportsCustomReceiveFolders {
+			Section(String(localized: "preferences_receive_folder_title")) {
+				Text(model.state.receiveFolder?.displayName ?? String(localized: "value_unavailable"))
+					.foregroundStyle(.secondary)
+				Button(String(localized: "button_choose_folder"), action: model.chooseReceiveFolder)
+				Button(String(localized: "button_reset_default"), action: model.resetReceiveFolder)
+			}
+		}
+	}
+}
+
+struct AppearanceSettings: View {
+	@ObservedObject var model: SettingsModel
+
+	var body: some View {
+		Section {
+			Picker(String(localized: "appearance_title"),
+				   selection: Binding(get: { model.state.themeMode }, set: { model.setThemeMode($0) })) {
+				ForEach(ThemeMode.allCases, id: \.self) { mode in
+					Text(themeModeLabel(mode)).tag(mode)
+				}
+			}
+			.pickerStyle(.inline)
+			.labelsHidden()
+		}
+	}
+}
+
+struct NotificationSettings: View {
+	@ObservedObject var model: SettingsModel
+
+	var body: some View {
+		Section {
+			Toggle(isOn: Binding(
+				get: { model.state.notificationsEnabled },
+				set: { model.setNotificationsEnabled($0) }
+			)) {
+				Text(LocalizedStringKey("notifications_local_title"))
+			}
+			if model.state.notificationPermission == .denied {
+				Button(String(localized: "button_open_settings"), action: model.openNotificationSettings)
+			}
+		}
+	}
+}
+
+struct AboutSettings: View {
+	@ObservedObject var model: SettingsModel
+
+	var body: some View {
+		Section(String(localized: "about_title")) {
+			LabeledContent(String(localized: "version_title"), value: model.state.appVersion)
+			if let device = model.state.deviceInfo {
+				LabeledContent(String(localized: "device_model_title"), value: device.deviceModel ?? "—")
+				LabeledContent(String(localized: "os_version_title"), value: device.operatingSystem)
+			}
+		}
+		if DiagnosticsBuildConfig.included {
+			Section {
+				Toggle(isOn: Binding(
+					get: { model.state.diagnosticsEnabled },
+					set: { model.setDiagnosticsEnabled($0) }
+				)) {
+					Text(LocalizedStringKey("diagnostics_title"))
+				}
+			}
+		}
+		Section {
+			NavigationLink(value: SettingsSection.bugReport) {
+				Text(LocalizedStringKey("about_bug_report"))
+			}
+		}
+	}
+}
+
+struct BugReportSettings: View {
+	@ObservedObject var model: SettingsModel
+
+	var body: some View {
+		Section(String(localized: "bug_report_what_label")) {
+			TextField(String(localized: "bug_report_what_label"),
+					  text: Binding(get: { model.state.bugWhatHappened }, set: model.setBugWhatHappened), axis: .vertical)
+				.lineLimit(3, reservesSpace: true)
+		}
+		Section(String(localized: "bug_report_expected_label")) {
+			TextField(String(localized: "bug_report_expected_label"),
+					  text: Binding(get: { model.state.bugExpected }, set: model.setBugExpected), axis: .vertical)
+				.lineLimit(3, reservesSpace: true)
+		}
+		Section(String(localized: "bug_report_steps_label")) {
+			TextField(String(localized: "bug_report_steps_label"),
+					  text: Binding(get: { model.state.bugSteps }, set: model.setBugSteps), axis: .vertical)
+				.lineLimit(3, reservesSpace: true)
+		}
+		Section(String(localized: "bug_report_contact_label")) {
+			TextField(String(localized: "bug_report_contact_label"),
+					  text: Binding(get: { model.state.bugContact }, set: model.setBugContact))
+		}
+		Section {
+			Toggle(isOn: Binding(get: { model.state.bugIncludeLogs }, set: { model.setBugIncludeLogs($0) })) {
+				Text(LocalizedStringKey("bug_report_include_logs"))
+			}
+			Button(action: model.submitBugReport) {
+				Text(model.state.isSubmittingBugReport
+					 ? String(localized: "bug_report_submitting") : String(localized: "bug_report_submit"))
+			}
+			.disabled(model.state.isSubmittingBugReport)
+		}
+	}
+}