Commit `872583eca8`

872583eca8b4e7ae6ef85917604d4a5257b9d125

parent: d3af0e7d51

Unsigned

cmc <hello@cleberg.net> · 2026-07-23 02:43 UTC

fix: adopt Swift 6 language mode; resolve all concurrency issues (#27)

All three product targets (app, widget, share extension) now build under
SWIFT_VERSION = 6.0 with zero errors and zero warnings. The UITests
target stays on 5.0: XCTestCase's nonisolated setUp/init overrides
conflict with the target's MainActor default isolation under 6, and test
tooling is not shipping code.

The original seven diagnostics, plus the layers Swift 6 mode surfaced
once those cleared:

- SMTPChannel is an actor. It was implicitly MainActor while running its
  receive loop on a background queue, so parsedLines/lineWaiters/
  receiveBuffer were declared main-actor-protected and mutated off it —
  concurrent mutation while resuming a CheckedContinuation can
  double-resume, which traps. The actor serialises all state; Network
  callbacks hop in via Task. The start() continuation also gains an
  OSAllocatedUnfairLock resume-once guard: the state handler can fire
  .ready and later .failed, and resuming twice was a pre-existing trap of
  the same family.
- CachedLookupResult is nonisolated (a value pair built inside actor
  LookupRuntime cannot have a MainActor-bound memberwise init) with
  conditional Sendable — opting out of MainActor isolation also opted out
  of the implicit Sendable that globally-isolated types get.
- PortScanService.printableBanner is nonisolated: a pure transformation
  called from the connection's queue.
- SweepActivityController stores the activity's Sendable id instead of
  the non-Sendable Activity, re-resolving via Activity.activities inside
  each fire-and-forget task, so nothing non-Sendable crosses isolation.
- App Intents' static title/description/openAppWhenRun become lets
  (get-only protocol requirements; static var is shared mutable global
  state), and the summary helpers are @MainActor to match the model
  properties they read and the perform() implementations that call them.
- ExternalDataService's ISO8601DateFormatter is nonisolated(unsafe),
  citing Apple's documented thread-safety, rather than risking a parser
  behaviour change by switching APIs with no test coverage.
- TaskMetricsDelegate.metrics is nonisolated(unsafe): written on the
  session's delegate queue, read only after the request completes, and
  URLSession guarantees didFinishCollecting precedes task completion.
- The share extension extracts the host via async/withCheckedContinuation
  instead of sending a non-Sendable completion into loadItem's @Sendable
  handler; Task inherits the view controller's MainActor so the manual
  DispatchQueue.main hop goes too.

Validated: clean Swift 6 build of all product targets, and the full
enforced 11-test audit suite green on the floor runtime — Swift 6's
runtime isolation checks ran the app through every screen without a
trap.

Layout: unified · split

DomainDig.xcodeproj/project.pbxproj +6 −6

	@@ -591,7 +591,7 @@
591	SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;	591	SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
592	SWIFT_EMIT_LOC_STRINGS = YES;	592	SWIFT_EMIT_LOC_STRINGS = YES;
593	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;	593	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
594	SWIFT_VERSION = 5.0;	594	SWIFT_VERSION = 6.0;
595	TARGETED_DEVICE_FAMILY = "1,2";	595	TARGETED_DEVICE_FAMILY = "1,2";
596	};	596	};
597	name = Debug;	597	name = Debug;
	@@ -628,7 +628,7 @@
628	SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;	628	SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor;
629	SWIFT_EMIT_LOC_STRINGS = YES;	629	SWIFT_EMIT_LOC_STRINGS = YES;
630	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;	630	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
631	SWIFT_VERSION = 5.0;	631	SWIFT_VERSION = 6.0;
632	TARGETED_DEVICE_FAMILY = "1,2";	632	TARGETED_DEVICE_FAMILY = "1,2";
633	};	633	};
634	name = Release;	634	name = Release;
	@@ -657,7 +657,7 @@
657	SWIFT_APPROACHABLE_CONCURRENCY = YES;	657	SWIFT_APPROACHABLE_CONCURRENCY = YES;
658	SWIFT_EMIT_LOC_STRINGS = YES;	658	SWIFT_EMIT_LOC_STRINGS = YES;
659	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;	659	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
660	SWIFT_VERSION = 5.0;	660	SWIFT_VERSION = 6.0;
661	TARGETED_DEVICE_FAMILY = "1,2";	661	TARGETED_DEVICE_FAMILY = "1,2";
662	};	662	};
663	name = Debug;	663	name = Debug;
	@@ -686,7 +686,7 @@
686	SWIFT_APPROACHABLE_CONCURRENCY = YES;	686	SWIFT_APPROACHABLE_CONCURRENCY = YES;
687	SWIFT_EMIT_LOC_STRINGS = YES;	687	SWIFT_EMIT_LOC_STRINGS = YES;
688	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;	688	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
689	SWIFT_VERSION = 5.0;	689	SWIFT_VERSION = 6.0;
690	TARGETED_DEVICE_FAMILY = "1,2";	690	TARGETED_DEVICE_FAMILY = "1,2";
691	};	691	};
692	name = Release;	692	name = Release;
	@@ -715,7 +715,7 @@
715	SWIFT_APPROACHABLE_CONCURRENCY = YES;	715	SWIFT_APPROACHABLE_CONCURRENCY = YES;
716	SWIFT_EMIT_LOC_STRINGS = YES;	716	SWIFT_EMIT_LOC_STRINGS = YES;
717	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;	717	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
718	SWIFT_VERSION = 5.0;	718	SWIFT_VERSION = 6.0;
719	TARGETED_DEVICE_FAMILY = "1,2";	719	TARGETED_DEVICE_FAMILY = "1,2";
720	};	720	};
721	name = Debug;	721	name = Debug;
	@@ -744,7 +744,7 @@
744	SWIFT_APPROACHABLE_CONCURRENCY = YES;	744	SWIFT_APPROACHABLE_CONCURRENCY = YES;
745	SWIFT_EMIT_LOC_STRINGS = YES;	745	SWIFT_EMIT_LOC_STRINGS = YES;
746	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;	746	SWIFT_UPCOMING_FEATURE_MEMBER_IMPORT_VISIBILITY = YES;
747	SWIFT_VERSION = 5.0;	747	SWIFT_VERSION = 6.0;
748	TARGETED_DEVICE_FAMILY = "1,2";	748	TARGETED_DEVICE_FAMILY = "1,2";
749	};	749	};
750	name = Release;	750	name = Release;

DomainDig/DomainDigIntents.swift +11 −9

 /// `DomainReportBuilder`) and returns a concise summary. Usable from
 /// Shortcuts, Spotlight, the Action button, and Siri.
 struct InspectDomainIntent: AppIntent {
-    static var title: LocalizedStringResource = "Inspect Domain"
+    static let title: LocalizedStringResource = "Inspect Domain"
-    static var description = IntentDescription(
+    static let description = IntentDescription(
         "Run a DomainDig inspection and return a summary of availability, risk, TLS, email security, and certificate health."
     )
     // Read-only inspection; no need to foreground the app.
-    static var openAppWhenRun = false
+    static let openAppWhenRun = false
     @Parameter(
         title: "Domain",
     }
     /// Multi-line summary suitable for a returned Shortcuts text value.
+    @MainActor
     static func summaryText(for report: DomainReport) -> String {
         let dnssec: String
         switch report.dns.dnssecSigned {
     }
     /// Short spoken/dialog line for Siri and the Shortcuts result banner.
+    @MainActor
     static func spokenSummary(for report: DomainReport) -> String {
         "\(report.domain) is \(report.availability.rawValue). Risk \(report.riskAssessment.level.title.lowercased()), health \(report.health.title.lowercased())."
     }
 /// existing view-model path (premium limits, monitoring, history linking,
 /// cloud-sync recording, and the paywall when over the free limit).
 struct AddToWatchlistIntent: AppIntent {
-    static var title: LocalizedStringResource = "Add Domain to Watchlist"
+    static let title: LocalizedStringResource = "Add Domain to Watchlist"
-    static var description = IntentDescription(
+    static let description = IntentDescription(
         "Open DomainDig and add a domain to your watchlist."
     )
-    static var openAppWhenRun = true
+    static let openAppWhenRun = true
     @Parameter(
         title: "Domain",
 /// through the existing view-model batch path (`refreshAllTrackedDomains`), which
 /// enforces the batch feature gate and surfaces the paywall when needed.
 struct RunSweepIntent: AppIntent {
-    static var title: LocalizedStringResource = "Run Watchlist Sweep"
+    static let title: LocalizedStringResource = "Run Watchlist Sweep"
-    static var description = IntentDescription(
+    static let description = IntentDescription(
         "Open DomainDig and re-inspect every domain on your watchlist."
     )
-    static var openAppWhenRun = true
+    static let openAppWhenRun = true
     @MainActor
     func perform() async throws -> some IntentResult {

DomainDig/ExternalDataService.swift +4 −1

         }
     }
-    private static let iso8601DateFormatter: ISO8601DateFormatter = {
+    // ISO8601DateFormatter is documented thread-safe ("ISO8601DateFormatter is
+    // thread-safe" — Apple docs), so sharing one instance across contexts is
+    // sound; the annotation records that the compiler cannot see it. (#27)
+    private nonisolated(unsafe) static let iso8601DateFormatter: ISO8601DateFormatter = {
         let formatter = ISO8601DateFormatter()
         formatter.formatOptions = [.withInternetDateTime, .withFractionalSeconds]
         return formatter

DomainDig/HTTPHeadersService.swift +4 −1

 }
 private final class TaskMetricsDelegate: NSObject, URLSessionTaskDelegate {
-    private(set) var metrics: URLSessionTaskMetrics?
+    // Written from the session's delegate queue, read only after the request
+    // has completed — URLSession guarantees didFinishCollecting is delivered
+    // before the task finishes, so the accesses are sequenced. (#27)
+    nonisolated(unsafe) private(set) var metrics: URLSessionTaskMetrics?
     func urlSession(
         _ _: URLSession,

DomainDig/IntegrationService.swift +49 −25

	@@ -1,5 +1,6 @@
1	import Foundation	1	import Foundation
2	import Network	2	import Network
		3	import os
3	import Observation	4	import Observation
4	import Security	5	import Security
5		6
	@@ -749,11 +750,17 @@ private enum SMTPClient {
749	try await channel.sendRaw(body + "\r\n.\r\n")	750	try await channel.sendRaw(body + "\r\n.\r\n")
750	_ = try await channel.readResponse(expecting: [250])	751	_ = try await channel.readResponse(expecting: [250])
751	_ = try await channel.sendCommand("QUIT", expecting: [221])	752	_ = try await channel.sendCommand("QUIT", expecting: [221])
752	channel.cancel()	753	await channel.cancel()
753	}	754	}
754	}	755	}
755		756
756	private final class SMTPChannel {	757	/// An actor, not a MainActor class. The previous shape inherited the project's
		758	/// MainActor default while running its receive loop on a background dispatch
		759	/// queue, so `parsedLines`/`lineWaiters`/`receiveBuffer` were declared
		760	/// main-actor-protected and mutated off it — concurrent mutation while resuming
		761	/// a `CheckedContinuation` can double-resume, which traps. The actor serialises
		762	/// all of it and forces the Network callbacks to hop in explicitly. (Issue #27.)
		763	private actor SMTPChannel {
757	private let connection: NWConnection	764	private let connection: NWConnection
758	private var parsedLines: [String] = []	765	private var parsedLines: [String] = []
759	private var lineWaiters: [CheckedContinuation<String, Error>] = []	766	private var lineWaiters: [CheckedContinuation<String, Error>] = []
	@@ -765,25 +772,35 @@ private final class SMTPChannel {
765		772
766	func start() async throws {	773	func start() async throws {
767	try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in	774	try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, Error>) in
768	connection.stateUpdateHandler = { [weak self] state in	775	// The state handler can fire `.ready` and later `.failed` (or
		776	// `.failed` twice); resuming a continuation twice traps. The lock
		777	// also keeps the closure Sendable-clean without touching actor state
		778	// from the connection's queue.
		779	let hasResumed = OSAllocatedUnfairLock(initialState: false)
		780	connection.stateUpdateHandler = { state in
		781	let isFirst: () -> Bool = {
		782	hasResumed.withLock { resumed in
		783	if resumed { return false }
		784	resumed = true
		785	return true
		786	}
		787	}
769	switch state {	788	switch state {
770	case .ready:	789	case .ready:
771	self?.scheduleReceiveLoop()	790	if isFirst() { continuation.resume() }
772	continuation.resume()
773	case .failed(let error):	791	case .failed(let error):
774	continuation.resume(throwing: error)	792	if isFirst() { continuation.resume(throwing: error) }
		793	case .cancelled:
		794	if isFirst() { continuation.resume(throwing: IntegrationError.streamClosed) }
775	default:	795	default:
776	break	796	break
777	}	797	}
778	}	798	}
779	connection.start(queue: .global(qos: .utility))	799	connection.start(queue: .global(qos: .utility))
780	}	800	}
781	}	801	// Started from the actor once the connection is ready, replacing the old
782		802	// dispatch-queue hop. TCP buffers anything that arrives in the gap.
783	private func scheduleReceiveLoop() {	803	startReceiveLoop()
784	DispatchQueue.global(qos: .utility).async { [weak self] in
785	self?.startReceiveLoop()
786	}
787	}	804	}
788		805
789	func cancel() {	806	func cancel() {
	@@ -845,26 +862,33 @@ private final class SMTPChannel {
845	}	862	}
846		863
847	private func startReceiveLoop() {	864	private func startReceiveLoop() {
		865	// The completion runs on the connection's queue; hop back onto the
		866	// actor before touching any state.
848	connection.receive(minimumIncompleteLength: 1, maximumLength: 4096) { [weak self] data, _, isComplete, error in	867	connection.receive(minimumIncompleteLength: 1, maximumLength: 4096) { [weak self] data, _, isComplete, error in
849	guard let self else { return }	868	guard let self else { return }
850		869	Task {
851	if let error {	870	await self.handleReceive(data: data, isComplete: isComplete, error: error)
852	self.failWaiters(with: error)
853	return
854	}	871	}
		872	}
		873	}
855		874
856	if let data, !data.isEmpty {	875	private func handleReceive(data: Data?, isComplete: Bool, error: Error?) {
857	self.receiveBuffer.append(data)	876	if let error {
858	self.flushBuffer()	877	failWaiters(with: error)
859	}	878	return
		879	}
860		880
861	if isComplete {	881	if let data, !data.isEmpty {
862	self.failWaiters(with: IntegrationError.streamClosed)	882	receiveBuffer.append(data)
863	return	883	flushBuffer()
864	}	884	}
865		885
866	self.startReceiveLoop()	886	if isComplete {
		887	failWaiters(with: IntegrationError.streamClosed)
		888	return
867	}	889	}
		890
		891	startReceiveLoop()
868	}	892	}
869		893
870	private func flushBuffer() {	894	private func flushBuffer() {

DomainDig/LookupRuntime.swift +9 −1

 import Foundation
-struct CachedLookupResult<Value> {
+/// Opted out of the project's MainActor default isolation: this is a plain
+/// value pair constructed inside `actor LookupRuntime`, and a MainActor-bound
+/// memberwise init cannot be called from there under Swift 6.
+nonisolated struct CachedLookupResult<Value> {
     let value: Value
     let source: LookupResultSource
 }
+/// Opting out of MainActor isolation also opted out of the implicit
+/// Sendable that globally-isolated types get, which is what lets this cross
+/// from `actor LookupRuntime` back to its callers.
+extension CachedLookupResult: Sendable where Value: Sendable {}
 actor LookupRuntime {
     static let shared = LookupRuntime()

DomainDig/PortScanService.swift +4 −1

         }
     }
-    private static func printableBanner(from data: Data?, error: Error?) -> String? {
+    /// Pure data transformation, called from the connection's background queue —
+    /// `nonisolated` opts it out of the project's MainActor default, which would
+    /// otherwise make this call a data-race diagnostic under Swift 6.
+    private nonisolated static func printableBanner(from data: Data?, error: Error?) -> String? {
         guard error == nil,
               let data,
               !data.isEmpty,

DomainDig/SweepActivityController.swift +27 −12

 import Foundation
 /// Starts, updates, and ends the sweep Live Activity around a batch run.
+///
+/// Holds the activity's `id` (a Sendable `String`) rather than the
+/// `Activity` object itself. `Activity` is not Sendable, and sending the
+/// stored reference into the fire-and-forget update task while `self` still
+/// held it was a Swift 6 region-isolation violation (issue #27). Each task
+/// re-resolves the activity via `Activity.activities`, ActivityKit's
+/// sanctioned lookup, so nothing non-Sendable crosses an isolation boundary.
 @MainActor
 final class SweepActivityController {
     static let shared = SweepActivityController()
-    private var activity: Activity<SweepActivityAttributes>?
+    private var activityID: String?
     private init() { /* Singleton; use the shared instance. */ }
             changed: 0,
             warnings: 0
         )
-        activity = try? Activity.request(
+        let activity = try? Activity.request(
             attributes: SweepActivityAttributes(title: title, startedAt: Date()),
             content: ActivityContent(state: state, staleDate: nil)
         )
+        activityID = activity?.id
     }
     func update(completed: Int, total: Int, currentDomain: String?) {
-        guard let activity else { return }
+        guard let activityID else { return }
         let state = SweepActivityAttributes.ContentState(
             completed: completed,
             total: total,
             warnings: 0
         )
         Task {
+            guard let activity = Self.activity(withID: activityID) else { return }
             await activity.update(ActivityContent(state: state, staleDate: nil))
         }
     }
     func end(changed: Int, warnings: Int, immediately: Bool = false) {
-        guard let activity else { return }
+        guard let activityID else { return }
-        self.activity = nil
+        self.activityID = nil
-        let state = SweepActivityAttributes.ContentState(
-            completed: activity.content.state.total,
-            total: activity.content.state.total,
-            currentDomain: nil,
-            changed: changed,
-            warnings: warnings
-        )
         Task {
+            guard let activity = Self.activity(withID: activityID) else { return }
+            let total = activity.content.state.total
+            let state = SweepActivityAttributes.ContentState(
+                completed: total,
+                total: total,
+                currentDomain: nil,
+                changed: changed,
+                warnings: warnings
+            )
             await activity.end(
                 ActivityContent(state: state, staleDate: nil),
                 dismissalPolicy: immediately ? .immediate : .after(Date().addingTimeInterval(60))
             )
         }
     }
+    private nonisolated static func activity(withID id: String) -> Activity<SweepActivityAttributes>? {
+        Activity<SweepActivityAttributes>.activities.first { $0.id == id }
+    }
 }

DomainDigShareExtension/ShareViewController.swift +15 −11

             label.trailingAnchor.constraint(lessThanOrEqualTo: view.trailingAnchor, constant: -24)
         ])
-        extractSharedDomain { [weak self] domain in
+        // Task inherits this view controller's MainActor context, so finish()
-            DispatchQueue.main.async {
+        // lands back on main without a manual dispatch. The continuation form
-                self?.finish(domain: domain)
+        // also avoids sending a non-Sendable completion into loadItem's
-            }
+        // @Sendable handler. (#27)
+        Task { [weak self] in
+            let domain = await self?.extractSharedDomain()
+            self?.finish(domain: domain ?? nil)
         }
     }
-    private func extractSharedDomain(completion: @escaping (String?) -> Void) {
+    private func extractSharedDomain() async -> String? {
         let providers = (extensionContext?.inputItems ?? [])
             .compactMap { $0 as? NSExtensionItem }
             .flatMap { $0.attachments ?? [] }
         guard let provider = providers.first(where: {
             $0.hasItemConformingToTypeIdentifier(UTType.url.identifier)
         }) else {
-            completion(nil)
+            return nil
-            return
         }
-        provider.loadItem(forTypeIdentifier: UTType.url.identifier) { item, _ in
+        return await withCheckedContinuation { continuation in
-            let url = item as? URL ?? (item as? Data).flatMap { URL(dataRepresentation: $0, relativeTo: nil) }
+            provider.loadItem(forTypeIdentifier: UTType.url.identifier) { item, _ in
-            let host = url?.host?.trimmingCharacters(in: .whitespacesAndNewlines)
+                let url = item as? URL ?? (item as? Data).flatMap { URL(dataRepresentation: $0, relativeTo: nil) }
-            completion(host?.isEmpty == false ? host : nil)
+                let host = url?.host?.trimmingCharacters(in: .whitespacesAndNewlines)
+                continuation.resume(returning: host?.isEmpty == false ? host : nil)
+            }
         }
     }

Commit 872583eca8

Commit `872583eca8`