swift6-concurrency — independently scanned and version-tracked by SaferSkills.
SaferSkills independently audited swift6-concurrency (Agent Skill) and scored it 100/100 (green). The audit ran 55 deterministic rules across Security, Supply Chain, Maintenance, Transparency, and Community; it found 0 high-severity and 0 lower-severity findings. The full rule-by-rule trace and per-finding evidence are below. Free, methodology-open.
Findings & checks · 0 flagged
Every scanned point with the score it earned and what moved between them.
First recorded scan — no prior version to compare against.
The primary manifest — the file an agent reads to learn what this artifact does.
Package.swift and setting swiftLanguageModes / SWIFT_STRICT_CONCURRENCY.@preconcurrency".SWIFT_DEFAULT_ACTOR_ISOLATION = MainActor + SWIFT_APPROACHABLE_CONCURRENCY = YES; the SwiftPM equivalent is swiftSettings: [.defaultIsolation(MainActor.self)], which requires // swift-tools-version: 6.2). Under this default an unannotated in-house type never leaves the main actor, so it does not need Sendable on its own account — Sendable is required only for a type that crosses into nonisolated code, an actor, or a module with a different isolation default. Declare it explicitly when it does (struct Foo: Sendable or final class Foo: Sendable — the latter only valid when the class is non-inheritable and every stored property is both Sendable and let; for classes with mutable state, prefer actor Foo or @unchecked Sendable with manual synchronisation).swiftpm-modularization): keep MainActor as the default for UI/App modules; Engine/Domain modules that are pure logic set swiftSettings: [.defaultIsolation(nil)] so they stay nonisolated by default and avoid needless main-actor hops. Work that must run off the main actor is marked explicitly with @concurrent (SE-0461) rather than left to inference.Sendable, with methods async throws. Keep that requirement even when the implementation is an actor: the protocol's Sendable is not what fails when a non-Sendable framework type (AVAssetTrack, VNRequest) is involved — what fails is the value crossing the boundary:| Symptom | Wrong fix | Right fix |
|---|---|---|
non-Sendable type 'X' cannot be returned from actor-isolated implementation to caller of protocol requirement | Dropping : Sendable from the protocol — does not silence it (verified on Swift 6.3.2, the same error appears with and without) | @preconcurrency import the framework whose type you don't own, or convert to a Sendable value type at the actor boundary and never return the framework object itself (preferred — makes the isolation real rather than asserted) |
@preconcurrency import X to isolate the import@preconcurrency during transition..swiftLanguageMode(.v5); in Xcode, Swift 5 mode with SWIFT_STRICT_CONCURRENCY = targeted) and move it back to .v6 once the dep catches up — don't drop the whole project: in Swift 6 mode strict concurrency is always complete, so setting targeted there does nothing.apple-platform-targets: the catalog toolchain is Xcode 26; Swift 6 language mode has been available since Xcode 16, so the language-mode choice does not constrain the deployment floor.swiftpm-modularization: swiftLanguageModes: [.v6] sets the default for the whole package; individual targets can opt down with swiftSettings: [.swiftLanguageMode(.v5)] (available since swift-tools-version 6.0) — useful when migrating a legacy dependency without blocking the rest of the package.apple-skills:guide-swift-concurrency (aggregated external): fixing the concurrent code itself — actors, structured concurrency, cancellation, strict-concurrency diagnostics. This skill stops at the build settings and the dependency boundary.apple-skills:swift-concurrency (aggregated external): API reference for async/await, Task, TaskGroup, AsyncSequence.references/official-docs.md.~30 seconds. Free. No account. Every finding cites a rule and a line of evidence.