Implement thread safety macros

Package.swift

@@ -1,14 +1,44 @@
 // swift-tools-version: 6.2
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
-import PackageDescription
+import CompilerPluginSupport
 import Foundation
+import PackageDescription
 
 let approachableConcurrencySettings: [SwiftSetting] = [
     .enableUpcomingFeature("InferIsolatedConformances"),
     .enableUpcomingFeature("NonisolatedNonsendingByDefault"),
 ]
 
+let macroPlugin = Target.macro(
+    name: "ArgmaxCoreMacroPlugin",
+    dependencies: [
+        .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+        .product(name: "SwiftSyntax", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax")
+    ]
+)
+
+let macroTarget = Target.target(
+    name: "ArgmaxCoreMacros",
+    dependencies: [
+        "ArgmaxCore",
+        "ArgmaxCoreMacroPlugin",
+        .product(name: "SwiftCompilerPlugin", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+    ],
+    swiftSettings: approachableConcurrencySettings
+)
+
+let macroTestTarget = Target.testTarget(
+    name: "ArgmaxCoreMacrosTests",
+    dependencies: [
+        "ArgmaxCoreMacros",
+        .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+        .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax")
+    ]
+)
+
 let package = Package(
     name: "whisperkit",
     platforms: [
@@ -34,6 +64,7 @@ let package = Package(
     dependencies: [
         .package(url: "https://github.com/huggingface/swift-transformers.git", .upToNextMinor(from: "1.1.6")),
         .package(url: "https://github.com/apple/swift-argument-parser.git", from: "1.7.0"),
+        .package(url: "https://github.com/swiftlang/swift-syntax", from: "602.0.0"),
     ] + (isServerEnabled() ? [
         .package(url: "https://github.com/vapor/vapor.git", from: "4.115.1"),
         .package(url: "https://github.com/apple/swift-openapi-generator", from: "1.10.2"),
@@ -45,6 +76,8 @@ let package = Package(
             name: "ArgmaxCore",
             swiftSettings: approachableConcurrencySettings
         ),
+        macroPlugin,
+        macroTarget,
         .target(
             name: "WhisperKit",
             dependencies: [
@@ -63,6 +96,7 @@ let package = Package(
             ],
             swiftSettings: approachableConcurrencySettings
         ),
+        macroTestTarget,
         .testTarget(
             name: "WhisperKitTests",
             dependencies: [

Sources/ArgmaxCore/ConcurrencyUtilities.swift

@@ -110,3 +110,57 @@ public actor EarlyStopActor {
         return shouldStop.removeValue(forKey: uuid)
     }
 }
+
+// MARK: - Mutex
+
+@dynamicMemberLookup
+public final class Mutex<Value: Sendable>: Sendable {
+    private let lock: OSAllocatedUnfairLock<Value>
+
+    public init(_ value: Value) {
+        lock = .init(initialState: value)
+    }
+
+    public var value: Value {
+        lock.withLock { $0 }
+    }
+
+    @discardableResult
+    public func mutate<Result: Sendable>(_ mutation: @Sendable (inout Value) throws -> Result) rethrows -> Result {
+        try lock.withLock { try mutation(&$0) }
+    }
+
+    /// Set to the new value and return the old value.
+    @discardableResult
+    public func set(_ newValue: Value) -> Value {
+        lock.withLock { value in
+            let oldValue = value
+            value = newValue
+            return oldValue
+        }
+    }
+
+    /// Set property to the new value and return the old value.
+    @discardableResult
+    public func set<T: Sendable>(_ keyPath: WritableKeyPath<Value, T>, to newValue: T) -> T {
+        lock.withLock { value in
+            let oldValue = value[keyPath: keyPath]
+            value[keyPath: keyPath] = newValue
+            return oldValue
+        }
+    }
+
+    public subscript<T: Sendable>(dynamicMember keyPath: WritableKeyPath<Value, T>) -> T {
+        get { value[keyPath: keyPath] }
+        set { lock.withLock { value in value[keyPath: keyPath] = newValue } }
+    }
+
+    public subscript<T>(dynamicMember keyPath: KeyPath<Value, T>) -> T {
+        value[keyPath: keyPath]
+    }
+}
+
+// MARK: - KeyPath + @unchecked @retroactive Sendable
+
+extension KeyPath: @unchecked @retroactive Sendable where Root: Sendable, Value: Sendable { }
+

Sources/ArgmaxCoreMacroPlugin/ArgmaxCoreMacroPlugin.swift

@@ -0,0 +1,14 @@
+//  For licensing see accompanying LICENSE.md file.
+//  Copyright © 2026 Argmax, Inc. All rights reserved.
+
+import SwiftCompilerPlugin
+import SwiftSyntaxMacros
+
+@main
+struct ArgmaxCoreMacroPlugin: CompilerPlugin {
+  let providingMacros: [Macro.Type] = [
+    ThreadSafeMacro.self,
+    ThreadSafeInitializerMacro.self,
+    ThreadSafePropertyMacro.self,
+  ]
+}

Sources/ArgmaxCoreMacroPlugin/Extensions/ClassDeclSyntax+Extensions.swift

@@ -0,0 +1,102 @@
+//  For licensing see accompanying LICENSE.md file.
+//  Copyright © 2026 Argmax, Inc. All rights reserved.
+
+import Foundation
+import SwiftCompilerPlugin
+import SwiftDiagnostics
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import RegexBuilder
+
+extension ClassDeclSyntax {
+    private static let trailingCallSuffixRegex = Regex {
+        "("
+        ZeroOrMore {
+            CharacterClass.anyOf(")").inverted
+        }
+        ")"
+        Anchor.endOfLine
+    }
+
+    private static let integerLiteralRegex = Regex {
+        Anchor.startOfLine
+        Optionally { "-" }
+        OneOrMore(.digit)
+        Anchor.endOfLine
+    }
+
+    private static let doubleLiteralRegex = Regex {
+        Anchor.startOfLine
+        Optionally { "-" }
+        OneOrMore(.digit)
+        Optionally { "." }
+        ZeroOrMore(.digit)
+        Anchor.endOfLine
+    }
+
+    private static let quotedStringRegex = Regex {
+        Anchor.startOfLine
+        "\""
+        ZeroOrMore {
+            CharacterClass.anyOf("\n").inverted
+        }
+        "\""
+        Anchor.endOfLine
+    }
+
+    /// Returns the list of mutable stored properties in the class.
+    var storedVariables: [(name: String, type: String, defaultValue: String?)] {
+        var storedVars = [(String, String, String?)]()
+
+        for member in memberBlock.members {
+            guard
+                let varDecl = member.decl.as(VariableDeclSyntax.self),
+                varDecl.isMutable
+            else { continue }
+
+            for binding in varDecl.bindings {
+                if
+                    binding.accessorBlock == nil,
+                    let pattern = binding.pattern.as(IdentifierPatternSyntax.self)
+                {
+                    let name = pattern.identifier.text.trimmingCharacters(in: .whitespacesAndNewlines)
+                    let defaultValue = binding.initializer?.value.trimmedDescription
+                        .trimmingCharacters(in: .whitespacesAndNewlines) ?? binding
+                        .typeAnnotation?.type.defaultValueForOptional
+
+                    if let typeAnnotation = binding.typeAnnotation {
+                        let type = typeAnnotation.type.trimmedDescription.trimmingCharacters(in: .whitespacesAndNewlines)
+                        storedVars.append((name, type, defaultValue))
+                    } else if let defaultValue {
+                        // Heuristically tries to infer the type from the default value
+                        let value = stripTrailingCallSuffix(from: defaultValue)
+                            .trimmingCharacters(in: .whitespacesAndNewlines)
+
+                        let type: String =
+                        if value == "true" || value == "false" {
+                            "Bool"
+                        } else if value.wholeMatch(of: Self.integerLiteralRegex) != nil {
+                            "Int"
+                        } else if value.wholeMatch(of: Self.doubleLiteralRegex) != nil {
+                            "Double"
+                        } else if value.wholeMatch(of: Self.quotedStringRegex) != nil {
+                            "String"
+                        } else {
+                            value
+                        }
+                        storedVars.append((name, type, defaultValue))
+                    }
+                }
+            }
+        }
+        return storedVars
+    }
+
+    private func stripTrailingCallSuffix(from value: String) -> String {
+        guard let match = value.firstMatch(of: Self.trailingCallSuffixRegex) else {
+            return value
+        }
+        return String(value[..<match.range.lowerBound])
+    }
+}

Sources/ArgmaxCoreMacroPlugin/Extensions/TypeSyntax+Extensions.swift

@@ -0,0 +1,13 @@
+//  For licensing see accompanying LICENSE.md file.
+//  Copyright © 2026 Argmax, Inc. All rights reserved.
+
+import SwiftSyntax
+
+extension TypeSyntax {
+  var defaultValueForOptional: String? {
+    if self.as(OptionalTypeSyntax.self) != nil {
+      return "nil"
+    }
+    return nil
+  }
+}

Sources/ArgmaxCoreMacroPlugin/Extensions/VariableDeclSyntax+Extensions.swift

@@ -0,0 +1,21 @@
+//  For licensing see accompanying LICENSE.md file.
+//  Copyright © 2026 Argmax, Inc. All rights reserved.
+
+import Foundation
+import SwiftSyntax
+
+extension VariableDeclSyntax {
+  var isMutable: Bool {
+    guard
+      bindingSpecifier.text == "var",
+      attributes.isEmpty,
+      bindings.count == 1,
+      let binding = bindings.first,
+      binding.accessorBlock == nil,
+      let _ = binding.pattern.as(IdentifierPatternSyntax.self)
+    else {
+      return false
+    }
+    return true
+  }
+}