Swift Package Index

Build Information

Successful build of Extentos, reference main (d61f70), with Swift 6.3 for macOS (SPM) on 3 Sep 2026 05:23:28 UTC.

Swift 6 data race errors: 0

Build Command

env DEVELOPER_DIR=/Applications/Xcode-26.5.0.app xcrun swift build --arch arm64

Build Log

 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:250:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 248 |
 249 |     func start() async throws {
 250 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:251:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 249 |     func start() async throws {
 250 |         stateLock.lock()
 251 |         if started { stateLock.unlock(); return }
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 252 |         started = true
 253 |         stateLock.unlock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:253:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 251 |         if started { stateLock.unlock(); return }
 252 |         started = true
 253 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 254 |
 255 |         // Ears: the SDK's own transcription stream (baseline segmenter —
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:313:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 311 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 312 |             if let self {
 313 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:315:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 313 |                 self.stateLock.lock()
 314 |                 self.brainWarmed = true
 315 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 316 |             }
 317 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:334:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 332 |
 333 |     func connect() async throws {
 334 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:337:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 335 |         let already = connected
 336 |         connected = true
 337 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 338 |         if already { return }
 339 |         feed(.start)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:351:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 349 |             await brain.prefillPrefix(instructions: instructions, tools: tools)
 350 |             if let self {
 351 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:353:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 351 |                 self.stateLock.lock()
 352 |                 self.brainWarmed = true
 353 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 354 |             }
 355 |         }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:359:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 357 |
 358 |     func disconnect() async {
 359 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 360 |         connected = false
 361 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:361:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 359 |         stateLock.lock()
 360 |         connected = false
 361 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 362 |         feed(.stop)
 363 |     }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:366:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 364 |
 365 |     func stop() async {
 366 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 367 |         let wasStarted = started
 368 |         started = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:370:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 368 |         started = false
 369 |         connected = false
 370 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 371 |         guard wasStarted else { return }
 372 |         EarsActivityHub.shared.setListener(nil)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:378:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 376 |         inferenceTask?.cancel()
 377 |         speakPump?.cancel()
 378 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 379 |         speechQueue.removeAll()
 380 |         currentSegment = ""
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:384:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 382 |         for (_, t) in timers { t.cancel() }
 383 |         timers.removeAll()
 384 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 385 |         endAudio() // a stop mid-sentence still closes the audio pair
 386 |         onAssistantEvent(.sessionEnded(reason: .user, message: nil))
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:732:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 730 |             guard let self else { return }
 731 |             while !Task.isCancelled {
 732 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 733 |                 guard !self.speechQueue.isEmpty else {
 734 |                     self.pumpRunning = false
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:736:36: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 734 |                     self.pumpRunning = false
 735 |                     self.speakingStartMs = 0
 736 |                     self.stateLock.unlock()
     |                                    `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 737 |                     // Queue drained and every segment has played out — the
 738 |                     // assistant has genuinely stopped talking.
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:744:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 742 |                 let segment = self.speechQueue.removeFirst()
 743 |                 self.currentSegment = segment
 744 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:746:32: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 744 |                 self.stateLock.unlock()
 745 |                 await self.speakSegment(segment)
 746 |                 self.stateLock.lock()
     |                                `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:748:32: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 746 |                 self.stateLock.lock()
 747 |                 self.currentSegment = ""
 748 |                 self.stateLock.unlock()
     |                                `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 749 |                 if Task.isCancelled { return }
 750 |                 self.feed(.speechCompleted)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:912:19: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 910 |         // post-greeting prefix warm still readies the cache for turn one.
 911 |         let tools = brainTools()
 912 |         stateLock.lock()
     |                   `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Impl/LocalRealtimeProvider.swift:914:19: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 912 |         stateLock.lock()
 913 |         let warmed = brainWarmed
 914 |         stateLock.unlock()
     |                   `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
 915 |         if !warmed {
 916 |             trace.record("greeting: brain still warming — instant canned ack")
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
[559/694] Compiling fence.cpp
[560/756] Compiling hadamard.cpp
[561/766] Compiling indexing.cpp
[562/766] Compiling event.cpp
[564/775] Compiling SwiftDiagnostics GroupedDiagnostics.swift
[565/775] Compiling SwiftDiagnostics Message.swift
[566/775] Compiling SwiftDiagnostics FixIt.swift
[567/776] Compiling SwiftDiagnostics DiagnosticDecorator.swift
[568/776] Compiling SwiftDiagnostics ANSIDiagnosticDecorator.swift
[569/776] Compiling SwiftDiagnostics BasicDiagnosticDecorator.swift
[570/776] Compiling SwiftDiagnostics Diagnostic.swift
[571/776] Emitting module SwiftDiagnostics
[572/776] Compiling SwiftDiagnostics Convenience.swift
[573/776] Compiling SwiftDiagnostics DiagnosticsFormatter.swift
[574/776] Compiling SwiftBasicFormat Trivia+FormatExtensions.swift
[575/776] Compiling SwiftBasicFormat SyntaxProtocol+Formatted.swift
[576/776] Compiling SwiftBasicFormat Syntax+Extensions.swift
[577/776] Compiling SwiftDiagnostics Note.swift
[578/781] Compiling Tokenizers String+PreTokenization.swift
[579/781] Compiling Tokenizers Normalizer.swift
[580/781] Compiling SwiftParser Attributes.swift
[581/781] Compiling SwiftParser Availability.swift
[582/781] Compiling SwiftParser CharacterInfo.swift
[583/781] Compiling SwiftParser CollectionNodes+Parsable.swift
[584/781] Compiling Tokenizers PreTokenizer.swift
[585/781] Compiling Tokenizers TokenLattice.swift
[586/781] Compiling Tokenizers Trie.swift
[587/782] Compiling Tokenizers Tokenizer.swift
[588/782] Compiling Tokenizers PostProcessor.swift
[589/782] Emitting module Tokenizers
[590/782] Compiling SwiftBasicFormat InferIndentation.swift
[591/782] Compiling SwiftBasicFormat Indenter.swift
[592/782] Emitting module SwiftBasicFormat
[593/782] Compiling SwiftBasicFormat BasicFormat.swift
[594/782] Compiling SwiftParser TokenConsumer.swift
[595/782] Compiling SwiftParser TokenPrecedence.swift
[596/782] Compiling SwiftParser TokenSpec.swift
[597/782] Compiling SwiftParser TokenSpecSet.swift
[602/788] Compiling SwiftParser CompilerFiles.swift
[603/788] Compiling SwiftParser StringLiterals.swift
[604/788] Compiling SwiftParser SwiftParserCompatibility.swift
[605/788] Compiling SwiftParser SwiftVersion.swift
[606/788] Compiling SwiftParser SyntaxUtils.swift
[607/788] Compiling SwiftParser RegexLiteralLexer.swift
[608/788] Compiling SwiftParser UnicodeScalarExtensions.swift
[609/788] Compiling SwiftParser Lookahead.swift
[610/788] Compiling SwiftParser LoopProgressCondition.swift
[611/788] Compiling SwiftParser Modifiers.swift
[612/788] Compiling SwiftParser Names.swift
[613/788] Compiling SwiftParser Nominals.swift
[614/788] Compiling SwiftParser Parameters.swift
[615/788] Compiling SwiftParser ParseSourceFile.swift
[616/788] Compiling SwiftParser Parser.swift
[617/788] Emitting module SwiftParser
[618/788] Compiling SwiftParser Patterns.swift
[619/788] Compiling SwiftParser Recovery.swift
[620/788] Compiling SwiftParser Specifiers.swift
[621/788] Compiling SwiftParser Statements.swift
[622/788] Compiling SwiftParser StringLiteralRepresentedLiteralValue.swift
[623/788] Compiling Tokenizers UnigramTokenizer.swift
[624/788] Compiling SwiftParser TopLevel.swift
[625/788] Compiling SwiftParser TriviaParser.swift
[626/788] Compiling SwiftParser Types.swift
[627/788] Compiling SwiftParser ExperimentalFeatures.swift
[628/788] Compiling SwiftParser IsValidIdentifier.swift
[629/788] Compiling SwiftParser Cursor.swift
[630/788] Compiling SwiftParser Lexeme.swift
[631/788] Compiling SwiftParser LexemeSequence.swift
[632/788] Compiling SwiftParser Lexer.swift
[632/788] Compiling eval.cpp
[633/788] Compiling distributed.cpp
[635/790] Compiling GlassesLocalVoice KokoroModelDownload.swift
[636/790] Emitting module GlassesLocalVoice
[637/790] Compiling GlassesLocalVoice KokoroModelManifest.swift
[638/790] Compiling GlassesLocalVoice KokoroSynthesizer.swift
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocalVoice/KokoroSynthesizer.swift:168:21: warning: 'SherpaOnnxOfflineTtsGenerateWithCallbackWithArg' is deprecated: Use SherpaOnnxOfflineTtsGenerateWithConfig() instead [#DeprecatedDeclaration]
166 |                 let arg = Unmanaged.passRetained(box).toOpaque()
167 |                 let audio = text.withCString { cText in
168 |                     SherpaOnnxOfflineTtsGenerateWithCallbackWithArg(
    |                     `- warning: 'SherpaOnnxOfflineTtsGenerateWithCallbackWithArg' is deprecated: Use SherpaOnnxOfflineTtsGenerateWithConfig() instead [#DeprecatedDeclaration]
169 |                         tts, cText, self.speakerId, 1.0, kokoroChunkCallback, arg
170 |                     )
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocalVoice/KokoroSynthesizer.swift:181:18: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
179 |             }
180 |         }
181 |         box.lock.lock()
    |                  `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
182 |         let cancelled = box.cancelled
183 |         box.lock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocalVoice/KokoroSynthesizer.swift:183:18: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
181 |         box.lock.lock()
182 |         let cancelled = box.cancelled
183 |         box.lock.unlock()
    |                  `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
184 |         guard !cancelled, totalSamples > 0 else { return nil }
185 |         return Double(totalSamples) / Double(rate)
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocalVoice/KokoroSynthesizer.swift:169:25: warning: capture of 'tts' with non-Sendable type 'OpaquePointer' in a '@Sendable' closure [#SendableClosureCaptures]
167 |                 let audio = text.withCString { cText in
168 |                     SherpaOnnxOfflineTtsGenerateWithCallbackWithArg(
169 |                         tts, cText, self.speakerId, 1.0, kokoroChunkCallback, arg
    |                         `- warning: capture of 'tts' with non-Sendable type 'OpaquePointer' in a '@Sendable' closure [#SendableClosureCaptures]
170 |                     )
171 |                 }
Swift.OpaquePointer:1:23: note: struct 'OpaquePointer' does not conform to the 'Sendable' protocol
1 | @frozen public struct OpaquePointer {
  |                       `- note: struct 'OpaquePointer' does not conform to the 'Sendable' protocol
2 | }
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocalVoice/KokoroSynthesizer.swift:190:18: warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
188 |     public func cancel() async {
189 |         guard let box = currentBox else { return }
190 |         box.lock.lock()
    |                  `- warning: instance method 'lock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
191 |         box.cancelled = true
192 |         box.lock.unlock()
Foundation.NSLock.lock:2:11: note: 'lock()' declared here
1 | class NSLock {
2 | open func lock()}
  |           `- note: 'lock()' declared here
3 |
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocalVoice/KokoroSynthesizer.swift:192:18: warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
190 |         box.lock.lock()
191 |         box.cancelled = true
192 |         box.lock.unlock()
    |                  `- warning: instance method 'unlock' is unavailable from asynchronous contexts; Use async-safe scoped locking instead; this is an error in the Swift 6 language mode
193 |     }
194 | }
Foundation.NSLock.unlock:2:11: note: 'unlock()' declared here
1 | class NSLock {
2 | open func unlock()}
  |           `- note: 'unlock()' declared here
3 |
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[639/790] Compiling GlassesLocalVoice KokoroServingProbe.swift
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocalVoice/KokoroServingProbe.swift:125:45: warning: 'SherpaOnnxOfflineTtsGenerate' is deprecated: Use SherpaOnnxOfflineTtsGenerateWithConfig() instead [#DeprecatedDeclaration]
123 |                                         let t0 = Date()
124 |                                         guard let audio = text.withCString({ c in
125 |                                             SherpaOnnxOfflineTtsGenerate(tts, c, 0, 1.0)
    |                                             `- warning: 'SherpaOnnxOfflineTtsGenerate' is deprecated: Use SherpaOnnxOfflineTtsGenerateWithConfig() instead [#DeprecatedDeclaration]
126 |                                         }) else {
127 |                                             parts.append("synthFAIL")
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[639/790] Compiling fft.cpp
[640/790] Compiling device_info.cpp
[642/790] Compiling SwiftParser Declarations.swift
[643/790] Compiling SwiftParser Directives.swift
[644/790] Compiling SwiftParser ExpressionInterpretedAsVersionTuple.swift
[645/790] Compiling SwiftParser Expressions.swift
[646/790] Compiling SwiftParser IncrementalParseTransition.swift
[647/790] Compiling SwiftParser IsLexerClassified.swift
[648/790] Compiling SwiftParser LayoutNodes+Parsable.swift
[649/790] Compiling SwiftParser Parser+TokenSpecSet.swift
[650/790] Compiling SwiftParser TokenSpecStaticMembers.swift
[651/790] Compiling GlassesLifecycle ListeningModifier.swift
[652/790] Emitting module GlassesLifecycle
[653/790] Compiling GlassesTesting FakeExtentosGlasses.swift
[654/790] Emitting module GlassesTesting
[655/790] Emitting module GlassesDebug
[656/790] Compiling GlassesDebug ExtentosDebugPanel.swift
[657/813] Compiling SwiftOperators PrecedenceGroup.swift
[658/814] Compiling SwiftOperators PrecedenceGraph.swift
[659/814] Compiling SwiftOperators OperatorTable.swift
[660/814] Compiling SwiftOperators SyntaxSynthesis.swift
[661/814] Compiling SwiftOperators OperatorTable+Semantics.swift
[662/814] Compiling SwiftOperators OperatorTable+Defaults.swift
[663/814] Emitting module SwiftOperators
[664/814] Compiling SwiftOperators Operator.swift
[665/814] Compiling SwiftOperators OperatorError+Diagnostics.swift
[666/814] Compiling SwiftOperators OperatorError.swift
[667/814] Compiling SwiftOperators OperatorTable+Folding.swift
[668/814] Compiling SwiftParserDiagnostics Utils.swift
[669/814] Compiling SwiftParserDiagnostics SyntaxKindNameForDiagnostics.swift
[670/814] Compiling SwiftParserDiagnostics ChildNameForDiagnostics.swift
[671/815] Compiling SwiftParserDiagnostics TokenNameForDiagnostics.swift
[672/815] Compiling SwiftParserDiagnostics SyntaxExtensions.swift
[673/815] Compiling SwiftParserDiagnostics PresenceUtils.swift
[674/815] Compiling SwiftParserDiagnostics ParserDiagnosticMessages.swift
[675/815] Compiling GlassesUI ExtentosTheme.swift
[676/815] Compiling GlassesUI ExtentosPairingScreen.swift
[677/815] Compiling GlassesUI EscapeHatch.swift
[678/815] Compiling GlassesUI ConnectionPageJsonConfig.swift
[679/815] Compiling GlassesUI Appearance.swift
[680/815] Emitting module GlassesUI
[681/815] Compiling GlassesUI ExtentosConnectionPage.swift
/Users/admin/builder/spi-builder-workspace/Sources/GlassesUI/ExtentosConnectionPage.swift:475:10: warning: 'onChange(of:perform:)' was deprecated in macOS 14.0: Use `onChange` with a two or zero parameter action closure instead. [#DeprecatedDeclaration]
473 |         .clipShape(appearance.shapes.card)
474 |         .hairlineBorder(appearance.shapes.card)
475 |         .onChange(of: toggle.value) { newValue in
    |          `- warning: 'onChange(of:perform:)' was deprecated in macOS 14.0: Use `onChange` with a two or zero parameter action closure instead. [#DeprecatedDeclaration]
476 |             localValue = newValue
477 |         }
[#DeprecatedDeclaration]: <https://docs.swift.org/compiler/documentation/diagnostics/deprecated-declaration>
[681/815] Compiling copy.cpp
[682/815] Compiling compiled.cpp
[684/815] Compiling SwiftParserDiagnostics MissingNodesError.swift
[685/815] Compiling SwiftParserDiagnostics MissingTokenError.swift
[686/815] Compiling SwiftParserDiagnostics DiagnosticExtensions.swift
[687/815] Compiling SwiftParserDiagnostics LexerDiagnosticMessages.swift
[688/815] Emitting module SwiftParserDiagnostics
[689/815] Compiling SwiftParserDiagnostics MultiLineStringLiteralDiagnosticsGenerator.swift
[690/815] Compiling SwiftParserDiagnostics ParseDiagnosticsGenerator.swift
[690/815] Compiling conv.cpp
[691/815] Compiling device.cpp
[692/815] Compiling slicing.cpp
[693/815] Compiling threefry.cpp
[694/830] Compiling custom_kernel.cpp
[695/830] Compiling allocator.cpp
[696/830] Compiling binary.cpp
[698/830] Compiling SwiftSyntaxBuilder RenamedChildrenBuilderCompatibility.swift
[699/830] Compiling SwiftSyntaxBuilder BuildableNodes.swift
[700/830] Compiling SwiftSyntaxBuilder WithTrailingCommaSyntax+EnsuringTrailingComma.swift
[701/830] Compiling SwiftSyntaxBuilder SyntaxParsable+ExpressibleByStringInterpolation.swift
[702/830] Compiling SwiftSyntaxBuilder ValidatingSyntaxNodes.swift
[703/830] Compiling SwiftSyntaxBuilder ResultBuilders.swift
[703/831] Compiling no_cuda.cpp
[705/831] Compiling SwiftSyntaxBuilder ResultBuilderExtensions.swift
[706/831] Compiling SwiftSyntaxBuilder SwiftSyntaxBuilderCompatibility.swift
[707/831] Compiling SwiftSyntaxBuilder Indenter.swift
[708/831] Compiling SwiftSyntaxBuilder ListBuilder.swift
[709/831] Compiling SwiftSyntaxBuilder ConvenienceInitializers.swift
[710/831] Compiling SwiftSyntaxBuilder DeclSyntaxParseable.swift
[711/831] Emitting module SwiftSyntaxBuilder
[712/831] Compiling SwiftSyntaxBuilder Syntax+StringInterpolation.swift
[713/831] Compiling SwiftSyntaxBuilder SyntaxNodeWithBody.swift
[713/831] Compiling copy.cpp
[714/831] Compiling primitives.cpp
[716/831] Compiling SwiftSyntaxBuilder SyntaxExpressibleByStringInterpolationConformances.swift
[716/831] Compiling softmax.cpp
[717/846] Compiling select.cpp
[719/846] Compiling SwiftIfConfig SyntaxLiteralUtils.swift
[720/846] Compiling SwiftIfConfig VersionTuple+Parsing.swift
[721/846] Compiling SwiftIfConfig SyntaxProtocol+IfConfig.swift
[722/847] Compiling SwiftIfConfig IfConfigFunctions.swift
[723/847] Compiling SwiftIfConfig IfConfigRegionState.swift
[724/847] Compiling SwiftIfConfig StaticBuildConfiguration.swift
[724/847] Compiling svd.cpp
[726/847] Compiling SwiftIfConfig VersionTuple.swift
[727/847] Compiling SwiftIfConfig ConfiguredRegions.swift
[728/847] Compiling SwiftIfConfig IfConfigDecl+IfConfig.swift
[729/847] Compiling SwiftIfConfig ActiveClauseEvaluator.swift
[730/847] Compiling SwiftIfConfig ActiveSyntaxRewriter.swift
[731/847] Compiling SwiftIfConfig ActiveSyntaxVisitor.swift
[732/847] Compiling SwiftIfConfig BuildConfiguration.swift
[733/847] Emitting module SwiftIfConfig
[734/847] Compiling SwiftIfConfig IfConfigDiagnostic.swift
[735/847] Compiling SwiftIfConfig IfConfigEvaluation.swift
[735/847] Compiling scan.cpp
[736/860] Compiling primitives.cpp
[738/865] Compiling SwiftSyntaxMacros PreambleMacro.swift
[739/866] Compiling SwiftSyntaxMacros Macro.swift
[740/866] Compiling SwiftSyntaxMacros MemberAttributeMacro.swift
[741/866] Compiling SwiftSyntaxMacros MemberMacro.swift
[742/866] Compiling SwiftSyntaxMacros PeerMacro.swift
[743/866] Compiling SwiftSyntaxMacros ExpressionMacro.swift
[744/866] Compiling SwiftSyntaxMacros ExtensionMacro.swift
[745/866] Compiling SwiftSyntaxMacros CodeItemMacro.swift
[746/866] Compiling SwiftSyntaxMacros DeclarationMacro.swift
[747/866] Compiling SwiftSyntaxMacros AttachedMacro.swift
[748/866] Compiling SwiftSyntaxMacros BodyMacro.swift
[749/866] Compiling SwiftSyntaxMacros FreestandingMacro.swift
[750/866] Compiling SwiftSyntaxMacros Macro+Format.swift
[751/866] Compiling SwiftSyntaxMacros MacroExpansionDiagnosticMessages.swift
[752/866] Compiling SwiftSyntaxMacros AccessorMacro.swift
[753/866] Emitting module SwiftSyntaxMacros
[754/866] Compiling SwiftSyntaxMacros AbstractSourceLocation.swift
[755/866] Compiling SwiftSyntaxMacros MacroExpansionContext.swift
[756/866] Compiling SwiftSyntaxMacros Syntax+LexicalContext.swift
[756/866] Compiling sort.cpp
[757/876] Compiling quantized.cpp
[758/876] Compiling unary.cpp
[759/876] Compiling qrf.cpp
[761/876] Compiling SwiftSyntaxMacroExpansion MacroReplacement.swift
[762/876] Compiling SwiftSyntaxMacroExpansion MacroSpec.swift
[763/876] Compiling SwiftSyntaxMacroExpansion MacroExpansionDiagnosticMessages.swift
[764/876] Compiling SwiftSyntaxMacroExpansion MacroExpansion.swift
[765/876] Compiling SwiftSyntaxMacroExpansion MacroArgument.swift
[766/876] Compiling SwiftSyntaxMacroExpansion IndentationUtils.swift
[767/876] Compiling SwiftSyntaxMacroExpansion FunctionParameterUtils.swift
[768/876] Compiling SwiftSyntaxMacroExpansion BasicMacroExpansionContext.swift
[769/876] Emitting module SwiftSyntaxMacroExpansion
[770/876] Compiling SwiftSyntaxMacroExpansion MacroSystem.swift
[770/876] Compiling jit_compiler.cpp
[771/876] Compiling reduce.cpp
[772/888] Compiling matmul.cpp
[774/888] Compiling SwiftCompilerPluginMessageHandling LRUCache.swift
[775/888] Compiling SwiftCompilerPluginMessageHandling PluginMessageCompatibility.swift
[776/888] Compiling SwiftCompilerPluginMessageHandling PluginMacroExpansionContext.swift
[777/888] Compiling SwiftCompilerPluginMessageHandling Macros.swift
[778/888] Compiling SwiftCompilerPluginMessageHandling JSONEncoding.swift
[779/888] Compiling SwiftCompilerPluginMessageHandling JSONDecoding.swift
[780/888] Compiling SwiftCompilerPluginMessageHandling CodingUtilities.swift
[781/888] Compiling SwiftCompilerPluginMessageHandling JSON.swift
[782/888] Compiling SwiftCompilerPluginMessageHandling CompilerPluginMessageHandler.swift
[783/888] Compiling SwiftCompilerPluginMessageHandling Diagnostics.swift
[784/888] Emitting module SwiftCompilerPluginMessageHandling
[785/888] Compiling SwiftCompilerPluginMessageHandling PluginMessages.swift
[785/889] Compiling hadamard.cpp
[785/889] Compiling logsumexp.cpp
[788/889] Compiling SwiftCompilerPluginMessageHandling StandardIOMessageConnection.swift
[788/889] Compiling masked_mm.cpp
[789/889] Compiling luf.cpp
[791/891] Emitting module SwiftCompilerPlugin
[792/891] Compiling SwiftCompilerPlugin CompilerPlugin.swift
[792/891] Compiling inverse.cpp
[793/893] Compiling cblas.cpp
[794/893] Compiling encoder.cpp
[795/893] Compiling bnns.cpp
[797/893] Emitting module MLXHuggingFaceMacros
[798/893] Compiling MLXHuggingFaceMacros HuggingFaceIntegrationMacros.swift
[798/893] Compiling eval.cpp
[799/893] Write Objects.LinkFileList
[800/893] Compiling device_info.cpp
[801/893] Compiling fft.cpp
[802/893] Compiling distributed.cpp
[803/893] Compiling indexing.cpp
[804/893] Linking MLXHuggingFaceMacros-tool
[805/893] Compiling eigh.cpp
[806/893] Compiling eig.cpp
[807/893] Compiling utils.cpp
[808/893] Compiling slicing.cpp
[809/893] Compiling arg_reduce.cpp
[810/893] Compiling reduce.cpp
[811/893] Compiling cholesky.cpp
[812/893] Compiling utils.cpp
[813/893] Compiling unary_ops.cpp
[814/893] Compiling unary.cpp
[815/893] Compiling ternary_ops.cpp
[816/893] Compiling ternary.cpp
[817/893] Compiling steel_gemm_splitk_nax.cpp
[818/893] Compiling steel_gemm_splitk.cpp
[819/893] Compiling steel_gemm_segmented.cpp
[820/893] Compiling steel_gemm_masked.cpp
[821/893] Compiling steel_gemm_gather_nax.cpp
[822/893] Compiling steel_gemm_gather.cpp
[823/893] Compiling steel_gemm_fused_nax.cpp
[824/893] Compiling steel_gemm_fused.cpp
[825/893] Compiling steel_conv_general.cpp
[826/893] Compiling steel_conv_3d.cpp
[827/893] Compiling steel_conv.cpp
[828/893] Compiling conv.cpp
[829/893] Compiling steel_attention_nax.cpp
[830/893] Compiling steel_attention.cpp
[831/893] Compiling sort.cpp
[832/893] Compiling softmax.cpp
[833/893] Compiling scatter_axis.cpp
[834/893] Compiling scatter.cpp
[835/893] Compiling scan.cpp
[836/893] Compiling reduce_utils.cpp
[837/893] Compiling reduce.cpp
[837/893] Compiling quantized_utils.cpp
[839/893] Compiling quantized_nax.cpp
[840/893] Compiling masked_scatter.cpp
[841/893] Compiling quantized.cpp
[842/893] Compiling logsumexp.cpp
[843/893] Compiling hadamard.cpp
[844/893] Compiling gemv_masked.cpp
[845/893] Compiling gemm_nax.cpp
[846/893] Compiling gemm.cpp
[847/893] Compiling gather_front.cpp
[848/893] Compiling load.cpp
[849/893] Compiling gather_axis.cpp
[850/893] Compiling gather.cpp
[851/893] Compiling fp_quantized_nax.cpp
[852/893] Compiling fp_quantized.cpp
[853/893] Compiling fft.cpp
[854/893] Compiling broadcasting.cpp
[855/893] Compiling copy.cpp
[856/893] Compiling conv.cpp
[857/893] Compiling binary_two.cpp
[858/893] Compiling compiled_preamble.cpp
[859/893] Compiling binary_ops.cpp
[860/893] Compiling binary.cpp
[861/893] Compiling arange.cpp
[862/893] Compiling compiled.cpp
[863/893] Compiling common.cpp
[864/893] Compiling copy.cpp
[865/893] Compiling array.cpp
[866/893] Compiling version.cpp
[867/893] Compiling transforms_impl.cpp
[868/893] Compiling transforms.cpp
[869/893] Compiling vector.cpp
[870/893] Compiling string.cpp
[871/893] Compiling stream.cpp
[872/893] Compiling compiled_conditional.cpp
[873/893] Compiling random.cpp
[874/893] Compiling ops.cpp
[875/893] Compiling metal.cpp
[876/893] Compiling memory.cpp
[877/893] Compiling linalg.cpp
[878/893] Compiling io_types.cpp
[879/893] Compiling map.cpp
[880/893] Compiling io.cpp
[881/893] Compiling error.cpp
[882/893] Compiling fft.cpp
[883/893] Compiling fast.cpp
[884/893] Compiling export.cpp
[885/893] Compiling device.cpp
[886/893] Compiling cuda.cpp
[887/893] Compiling compile.cpp
[888/893] Compiling format.cc
[889/893] Compiling closure.cpp
[890/893] Compiling binary.cpp
[891/893] Compiling Cmlx.m
[892/893] Compiling array.cpp
[894/930] Compiling MLX Transforms+Compile.swift
[895/930] Compiling MLX Transforms+CompileOverloads.swift
[896/930] Compiling MLX Transforms+Eval.swift
[897/930] Compiling MLX Transforms+Grad.swift
[898/934] Compiling MLX ArrayAt.swift
[899/934] Compiling MLX Cmlx+Util.swift
[900/934] Compiling MLX DType.swift
[901/934] Compiling MLX Device.swift
[902/934] Compiling MLX Protocols.swift
[903/934] Compiling MLX Random.swift
[904/934] Compiling MLX State.swift
[905/934] Compiling MLX Stream.swift
[906/934] Compiling MLX MLXCustomFunction.swift
[907/934] Compiling MLX MLXFast.swift
[908/934] Compiling MLX MLXFastKernel.swift
[909/934] Compiling MLX Memory.swift
[910/934] Compiling MLX ErrorHandler.swift
[911/934] Compiling MLX Export.swift
[912/934] Compiling MLX FFT.swift
[913/934] Compiling MLX Factory.swift
[914/934] Emitting module MLX
[915/934] Compiling MLX MLXArray+Normalizer.swift
[916/934] Compiling MLX MLXArray+Ops.swift
[917/934] Compiling MLX MLXArray+maskFill.swift
[918/934] Compiling MLX MLXArray.swift
[919/934] Compiling MLX Foundation+Util.swift
[920/934] Compiling MLX GPU+Metal.swift
[921/934] Compiling MLX IO.swift
[922/934] Compiling MLX Linalg.swift
[923/934] Compiling MLX Transforms+Internal.swift
[924/934] Compiling MLX Transforms+Vmap.swift
[925/934] Compiling MLX Transforms.swift
[926/934] Compiling MLX WiredMemory.swift
[927/934] Compiling MLX Nested.swift
[928/934] Compiling MLX Ops+Array.swift
[929/934] Compiling MLX Ops.swift
[930/934] Compiling MLX ParameterTypes.swift
[931/934] Compiling MLX MLXArray+Bytes.swift
[932/934] Compiling MLX MLXArray+Indexing.swift
[933/934] Compiling MLX MLXArray+Init.swift
[934/934] Compiling MLX MLXArray+Metal.swift
[935/952] Compiling MLXNN Containers.swift
[936/952] Compiling MLXNN Convolution.swift
[937/952] Compiling MLXNN Embedding.swift
[938/952] Compiling MLXNN Linear.swift
[939/952] Compiling MLXNN Normalization.swift
[940/952] Compiling MLXNN Pooling.swift
[941/952] Compiling MLXNN Activations.swift
[942/952] Compiling MLXNN Cache.swift
[943/952] Compiling MLXNN Losses.swift
[944/952] Compiling MLXNN Module.swift
[945/952] Compiling MLXNN ConvolutionTransposed.swift
[946/952] Compiling MLXNN Dropout.swift
[947/952] Compiling MLXNN Upsample.swift
[948/952] Compiling MLXNN PositionalEncoding.swift
[949/952] Compiling MLXNN Quantized.swift
[950/952] Compiling MLXNN Recurrent.swift
[951/952] Compiling MLXNN Transformer.swift
[952/952] Emitting module MLXNN
[953/953] Compiling MLXNN ValueAndGrad.swift
[954/956] Emitting module MLXOptimizers
[955/956] Compiling MLXOptimizers Optimizers.swift
[956/956] Compiling MLXOptimizers Schedulers.swift
[957/1018] Compiling MLXLMCommon DoRA+Layers.swift
[958/1018] Compiling MLXLMCommon LoRA+Layers.swift
[959/1018] Compiling MLXLMCommon LoRAContainer.swift
[960/1018] Compiling MLXLMCommon LoRAModel.swift
[961/1018] Compiling MLXLMCommon PEFTAdapter.swift
[962/1018] Compiling MLXLMCommon ModelAdapter.swift
[963/1018] Compiling MLXLMCommon ModelAdapterFactory.swift
[964/1024] Emitting module MLXLMCommon
[965/1024] Compiling MLXLMCommon RotateQuantizedLinear.swift
[966/1024] Compiling MLXLMCommon AbstractModelRegistry.swift
[967/1024] Compiling MLXLMCommon ModelTypeRegistry.swift
[968/1024] Compiling MLXLMCommon ProcessorTypeRegistry.swift
[969/1024] Compiling MLXLMCommon RoPEApplication.swift
[970/1024] Compiling MLXLMCommon RoPEUtils.swift
[971/1024] Compiling MLXLMCommon SpeculativeDecoding.swift
[972/1024] Compiling MLXLMCommon ModelAdapterTypeRegistry.swift
[973/1024] Compiling MLXLMCommon AttentionUtils.swift
[974/1024] Compiling MLXLMCommon BaseConfiguration.swift
[975/1024] Compiling MLXLMCommon BidirectionalMasks.swift
[976/1024] Compiling MLXLMCommon Chat.swift
[977/1024] Compiling MLXLMCommon ChatSession.swift
[978/1024] Compiling MLXLMCommon Downloader.swift
[979/1024] Compiling MLXLMCommon Value.swift
[980/1024] Compiling MLXLMCommon UserInput+Audio.swift
[981/1024] Compiling MLXLMCommon UserInput.swift
[982/1024] Compiling MLXLMCommon SerialAccessContainer.swift
[983/1024] Compiling MLXLMCommon WiredMemoryPolicies.swift
[984/1024] Compiling MLXLMCommon WiredMemoryUtils.swift
[985/1024] Compiling MLXLMCommon SuScaledRoPE.swift
[986/1024] Compiling MLXLMCommon SwitchLayers.swift
[987/1024] Compiling MLXLMCommon Tokenizer.swift
[988/1024] Compiling MLXLMCommon TokenizerLoader.swift
[989/1024] Compiling MLXLMCommon GLM4ToolCallParser.swift
[990/1024] Compiling MLXLMCommon GemmaFunctionParser.swift
[991/1024] Compiling MLXLMCommon JSONToolCallParser.swift
[992/1024] Compiling MLXLMCommon ModelContainer.swift
[993/1024] Compiling MLXLMCommon ModelConversion.swift
[994/1024] Compiling MLXLMCommon ModelFactory.swift
[995/1024] Compiling MLXLMCommon Gemma.swift
[996/1024] Compiling MLXLMCommon Gemma4.swift
[997/1024] Compiling MLXLMCommon Module+Extensions.swift
[998/1024] Compiling MLXLMCommon ParoQuantLoader.swift
[999/1024] Compiling MLXLMCommon KimiK2ToolCallParser.swift
[1000/1024] Compiling MLXLMCommon Llama3ToolCallParser.swift
[1001/1024] Compiling MLXLMCommon MiniMaxM2ToolCallParser.swift
[1002/1024] Compiling MLXLMCommon MistralToolCallParser.swift
[1003/1024] Compiling MLXLMCommon ParserUtilities.swift
[1004/1024] Compiling MLXLMCommon PythonicToolCallParser.swift
[1005/1024] Compiling MLXLMCommon XMLFunctionParser.swift
[1006/1024] Compiling MLXLMCommon Tool.swift
[1007/1024] Compiling MLXLMCommon ToolCall.swift
[1008/1024] Compiling MLXLMCommon ToolCallFormat.swift
[1009/1024] Compiling MLXLMCommon ToolCallProcessor.swift
[1010/1024] Compiling MLXLMCommon ToolParameter.swift
[1011/1024] Compiling MLXLMCommon Evaluate.swift
[1012/1024] Compiling MLXLMCommon Encodable+toolResult.swift
[1013/1024] Compiling MLXLMCommon JSONDecoder+JSON5.swift
[1014/1024] Compiling MLXLMCommon GatedDelta.swift
[1015/1024] Compiling MLXLMCommon GenerationConfigFile.swift
[1016/1024] Compiling MLXLMCommon InterpolationUtils.swift
[1017/1024] Compiling MLXLMCommon JSONDecodingTypes.swift
[1018/1024] Compiling MLXLMCommon KVCache.swift
[1019/1024] Compiling MLXLMCommon LanguageModel.swift
[1020/1024] Compiling MLXLMCommon Load.swift
[1021/1024] Compiling MLXLMCommon MTPDrafterModel.swift
[1022/1024] Compiling MLXLMCommon MTPDrafterModelFactory.swift
[1023/1024] Compiling MLXLMCommon MTPSpeculativeTokenIterator.swift
[1024/1024] Compiling MLXLMCommon ModelConfiguration.swift
[1025/1081] Compiling MLXHuggingFace Macros.swift
[1026/1081] Emitting module MLXHuggingFace
[1027/1081] Compiling MLXLLM LLMModel.swift
[1028/1081] Compiling MLXLLM LLMModelFactory.swift
[1029/1081] Compiling MLXLLM Lora+Data.swift
[1030/1081] Compiling MLXLLM LoraTrain.swift
[1031/1081] Compiling MLXLLM ModelConversion.swift
[1032/1081] Compiling MLXLLM AfMoE.swift
[1033/1086] Emitting module MLXLLM
[1034/1086] Compiling MLXLLM Phi3.swift
[1035/1086] Compiling MLXLLM PhiMoE.swift
[1036/1086] Compiling MLXLLM Qwen2.swift
[1037/1086] Compiling MLXLLM Qwen3.swift
[1038/1086] Compiling MLXLLM Qwen35.swift
[1039/1086] Compiling MLXLLM Qwen35MoE.swift
[1040/1086] Compiling MLXLLM GPTOSS.swift
[1041/1086] Compiling MLXLLM Gemma.swift
[1042/1086] Compiling MLXLLM Gemma2.swift
[1043/1086] Compiling MLXLLM Gemma3Text.swift
[1044/1086] Compiling MLXLLM Gemma3nText.swift
[1045/1086] Compiling MLXLLM Gemma4.swift
[1046/1086] Compiling MLXLLM Apertus.swift
[1047/1086] Compiling MLXLLM BaichuanM1.swift
[1048/1086] Compiling MLXLLM BailingMoe.swift
[1049/1086] Compiling MLXLLM Bitnet.swift
[1050/1086] Compiling MLXLLM Cohere.swift
[1051/1086] Compiling MLXLLM DeepseekV3.swift
[1052/1086] Compiling MLXLLM MiniCPM.swift
[1053/1086] Compiling MLXLLM MiniMax.swift
[1054/1086] Compiling MLXLLM Mistral3Text.swift
[1055/1086] Compiling MLXLLM Mixtral.swift
[1056/1086] Compiling MLXLLM NanoChat.swift
[1057/1086] Compiling MLXLLM NemotronH.swift
[1058/1086] Compiling MLXLLM LFM2MoE.swift
[1059/1086] Compiling MLXLLM Lille130m.swift
[1060/1086] Compiling MLXLLM Llama.swift
[1061/1086] Compiling MLXLLM Mamba2.swift
[1062/1086] Compiling MLXLLM MiMo.swift
[1063/1086] Compiling MLXLLM MiMoV2Flash.swift
[1064/1086] Compiling MLXLLM Ernie4_5.swift
[1065/1086] Compiling MLXLLM Exaone4.swift
[1066/1086] Compiling MLXLLM FalconH1.swift
[1067/1086] Compiling MLXLLM GLM4.swift
[1068/1086] Compiling MLXLLM GLM4MOE.swift
[1069/1086] Compiling MLXLLM GLM4MOELite.swift
[1070/1086] Compiling MLXLLM NemotronLabsDiffusion.swift
[1071/1086] Compiling MLXLLM Olmo2.swift
[1072/1086] Compiling MLXLLM Olmo3.swift
[1073/1086] Compiling MLXLLM OlmoE.swift
[1074/1086] Compiling MLXLLM OpenELM.swift
[1075/1086] Compiling MLXLLM Phi.swift
[1076/1086] Compiling MLXLLM Gemma4Text.swift
[1077/1086] Compiling MLXLLM Granite.swift
[1078/1086] Compiling MLXLLM GraniteMoeHybrid.swift
[1079/1086] Compiling MLXLLM Internlm2.swift
[1080/1086] Compiling MLXLLM Jamba.swift
[1081/1086] Compiling MLXLLM LFM2.swift
[1082/1086] Compiling MLXLLM Qwen3MoE.swift
[1083/1086] Compiling MLXLLM Qwen3Next.swift
[1084/1086] Compiling MLXLLM SSM.swift
[1085/1086] Compiling MLXLLM SmolLM3.swift
[1086/1086] Compiling MLXLLM Starcoder2.swift
[1087/1090] Compiling GlassesLocal LocalBrain.swift
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/LocalBrain.swift:513:74: warning: type 'any KVCache' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
511 |         let modelIdIn = config.modelId
512 |         traceCache("prefix warm begin")
513 |         let result: ([KVCache]?, [Int], String?)? = try? await container.perform {
    |                                                                          `- warning: type 'any KVCache' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
514 |             context -> ([KVCache]?, [Int], String?) in
515 |             let lmInput = try await context.processor.prepare(input: input)
/Users/admin/builder/spi-builder-workspace/.build/checkouts/mlx-swift-lm/Libraries/MLXLMCommon/KVCache.swift:46:17: note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  44 | ///
  45 | /// See ``LanguageModel/newCache(parameters:)``
  46 | public protocol KVCache: Evaluatable {
     |                 `- note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  47 |     /// get the current offset
  48 |     var offset: Int { get }
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/LocalBrain.swift:515:70: warning: capture of 'input' with non-Sendable type 'UserInput' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
513 |         let result: ([KVCache]?, [Int], String?)? = try? await container.perform {
514 |             context -> ([KVCache]?, [Int], String?) in
515 |             let lmInput = try await context.processor.prepare(input: input)
    |                                                                      `- warning: capture of 'input' with non-Sendable type 'UserInput' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
516 |             let fullTokens = lmInput.text.tokens.asArray(Int.self)
517 |             var cache = cacheIn
/Users/admin/builder/spi-builder-workspace/.build/checkouts/mlx-swift-lm/Libraries/MLXLMCommon/UserInput.swift:14:15: note: struct 'UserInput' does not conform to the 'Sendable' protocol
 12 | /// A ``UserInputProcessor`` can convert this to ``LMInput``.
 13 | /// See also ``ModelContext``.
 14 | public struct UserInput {
    |               `- note: struct 'UserInput' does not conform to the 'Sendable' protocol
 15 |
 16 |     /// Representation of a prompt or series of messages (conversation).
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/LocalBrain.swift:517:25: warning: capture of 'cacheIn' with non-Sendable type '[any KVCache]?' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
515 |             let lmInput = try await context.processor.prepare(input: input)
516 |             let fullTokens = lmInput.text.tokens.asArray(Int.self)
517 |             var cache = cacheIn
    |                         `- warning: capture of 'cacheIn' with non-Sendable type '[any KVCache]?' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
518 |             var fed = fedIn
519 |             var stateNote: String? = nil
/Users/admin/builder/spi-builder-workspace/.build/checkouts/mlx-swift-lm/Libraries/MLXLMCommon/KVCache.swift:46:17: note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  44 | ///
  45 | /// See ``LanguageModel/newCache(parameters:)``
  46 | public protocol KVCache: Evaluatable {
     |                 `- note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  47 |     /// get the current offset
  48 |     var offset: Int { get }
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/LocalBrain.swift:747:105: warning: type 'any KVCache' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
745 |             let resetReasonIn = lastResetReason
746 |             traceCache("gen begin: history=\(history.count) cached=\(fedIn.count) tok")
747 |             let (text, toolCalls, cacheOut, fedOut, alignment, resetNote, spoken) = try await container.perform {
    |                                                                                                         `- warning: type 'any KVCache' does not conform to the 'Sendable' protocol; this is an error in the Swift 6 language mode
748 |                 context -> (String, [ToolCall], [KVCache]?, [Int], String, String?, String) in
749 |                 let lmInput = try await context.processor.prepare(input: input)
/Users/admin/builder/spi-builder-workspace/.build/checkouts/mlx-swift-lm/Libraries/MLXLMCommon/KVCache.swift:46:17: note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  44 | ///
  45 | /// See ``LanguageModel/newCache(parameters:)``
  46 | public protocol KVCache: Evaluatable {
     |                 `- note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  47 |     /// get the current offset
  48 |     var offset: Int { get }
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/LocalBrain.swift:749:74: warning: capture of 'input' with non-Sendable type 'UserInput' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
747 |             let (text, toolCalls, cacheOut, fedOut, alignment, resetNote, spoken) = try await container.perform {
748 |                 context -> (String, [ToolCall], [KVCache]?, [Int], String, String?, String) in
749 |                 let lmInput = try await context.processor.prepare(input: input)
    |                                                                          `- warning: capture of 'input' with non-Sendable type 'UserInput' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
750 |                 let fullTokens = lmInput.text.tokens.asArray(Int.self)
751 |
/Users/admin/builder/spi-builder-workspace/.build/checkouts/mlx-swift-lm/Libraries/MLXLMCommon/UserInput.swift:14:15: note: struct 'UserInput' does not conform to the 'Sendable' protocol
 12 | /// A ``UserInputProcessor`` can convert this to ``LMInput``.
 13 | /// See also ``ModelContext``.
 14 | public struct UserInput {
    |               `- note: struct 'UserInput' does not conform to the 'Sendable' protocol
 15 |
 16 |     /// Representation of a prompt or series of messages (conversation).
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/LocalBrain.swift:753:29: warning: capture of 'cacheIn' with non-Sendable type '[any KVCache]?' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
751 |
752 |                 // ── Prompt-cache alignment (invariant: cache == fed) ──
753 |                 var cache = cacheIn
    |                             `- warning: capture of 'cacheIn' with non-Sendable type '[any KVCache]?' in a '@Sendable' closure; this is an error in the Swift 6 language mode [#SendableClosureCaptures]
754 |                 var fed = fedIn
755 |                 var disposition = "warm"
/Users/admin/builder/spi-builder-workspace/.build/checkouts/mlx-swift-lm/Libraries/MLXLMCommon/KVCache.swift:46:17: note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  44 | ///
  45 | /// See ``LanguageModel/newCache(parameters:)``
  46 | public protocol KVCache: Evaluatable {
     |                 `- note: protocol 'KVCache' does not conform to the 'Sendable' protocol
  47 |     /// get the current offset
  48 |     var offset: Int { get }
[#SendableClosureCaptures]: <https://docs.swift.org/compiler/documentation/diagnostics/sendable-closure-captures>
[1088/1090] Compiling GlassesLocal ExtentosLocalTier.swift
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/ExtentosLocalTier.swift:153:20: warning: stored property 'cloudReason' of 'Sendable'-conforming struct 'AutoChoice' contains non-Sendable type 'CloudFallbackReason'; this is an error in the Swift 6 language mode
151 |         /// the text worked on one platform and silently never matched on the
152 |         /// other. Switch on it; the wording shown to a user is the app's.
153 |         public let cloudReason: CloudFallbackReason?
    |                    `- warning: stored property 'cloudReason' of 'Sendable'-conforming struct 'AutoChoice' contains non-Sendable type 'CloudFallbackReason'; this is an error in the Swift 6 language mode
154 |         public let downloadTarget: String?
155 |     }
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Generated/extentos_core.swift:11120:13: note: enum 'CloudFallbackReason' does not conform to the 'Sendable' protocol
11118 |  */
11119 |
11120 | public enum CloudFallbackReason {
      |             `- note: enum 'CloudFallbackReason' does not conform to the 'Sendable' protocol
11121 |
11122 |     /**
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/ExtentosLocalTier.swift:13:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'GlassesCore'
 11 |
 12 | import Foundation
 13 | import GlassesCore
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'GlassesCore'
 14 | import HuggingFace
 15 | import os
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/ExtentosLocalTier.swift:397:20: warning: conditional cast from '[String : Any]' to '[String : any Sendable]' always succeeds
395 |             let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
396 |         else { return [:] }
397 |         return obj as? [String: any Sendable] ?? [:]
    |                    `- warning: conditional cast from '[String : Any]' to '[String : any Sendable]' always succeeds
398 |     }
399 | }
[1089/1090] Emitting module GlassesLocal
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/ExtentosLocalTier.swift:153:20: warning: stored property 'cloudReason' of 'Sendable'-conforming struct 'AutoChoice' contains non-Sendable type 'CloudFallbackReason'; this is an error in the Swift 6 language mode
151 |         /// the text worked on one platform and silently never matched on the
152 |         /// other. Switch on it; the wording shown to a user is the app's.
153 |         public let cloudReason: CloudFallbackReason?
    |                    `- warning: stored property 'cloudReason' of 'Sendable'-conforming struct 'AutoChoice' contains non-Sendable type 'CloudFallbackReason'; this is an error in the Swift 6 language mode
154 |         public let downloadTarget: String?
155 |     }
/Users/admin/builder/spi-builder-workspace/Sources/GlassesCore/Generated/extentos_core.swift:11120:13: note: enum 'CloudFallbackReason' does not conform to the 'Sendable' protocol
11118 |  */
11119 |
11120 | public enum CloudFallbackReason {
      |             `- note: enum 'CloudFallbackReason' does not conform to the 'Sendable' protocol
11121 |
11122 |     /**
/Users/admin/builder/spi-builder-workspace/Sources/GlassesLocal/ExtentosLocalTier.swift:13:1: warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'GlassesCore'
 11 |
 12 | import Foundation
 13 | import GlassesCore
    | `- warning: add '@preconcurrency' to suppress 'Sendable'-related warnings from module 'GlassesCore'
 14 | import HuggingFace
 15 | import os
[1090/1090] Compiling GlassesLocal AutoModelSelection.swift
Build complete! (75.40s)
Build complete.
{
  "dependencies" : [
    {
      "identity" : "meta-wearables-dat-ios",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "0.8.0",
            "upper_bound" : "0.9.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/facebook/meta-wearables-dat-ios"
    },
    {
      "identity" : "mlx-swift-lm",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "3.31.4",
            "upper_bound" : "4.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/ml-explore/mlx-swift-lm.git"
    },
    {
      "identity" : "swift-huggingface",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "0.1.0",
            "upper_bound" : "1.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/huggingface/swift-huggingface.git"
    },
    {
      "identity" : "swift-transformers",
      "requirement" : {
        "range" : [
          {
            "lower_bound" : "1.0.0",
            "upper_bound" : "2.0.0"
          }
        ]
      },
      "type" : "sourceControl",
      "url" : "https://github.com/huggingface/swift-transformers.git"
    }
  ],
  "manifest_display_name" : "Extentos",
  "name" : "Extentos",
  "path" : "/Users/admin/builder/spi-builder-workspace",
  "platforms" : [
    {
      "name" : "ios",
      "version" : "17.0"
    },
    {
      "name" : "macos",
      "version" : "14.0"
    }
  ],
  "products" : [
    {
      "name" : "GlassesCore",
      "targets" : [
        "GlassesCore"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "GlassesUI",
      "targets" : [
        "GlassesUI"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "GlassesDebug",
      "targets" : [
        "GlassesDebug"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "GlassesLifecycle",
      "targets" : [
        "GlassesLifecycle"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "GlassesTesting",
      "targets" : [
        "GlassesTesting"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "GlassesLocal",
      "targets" : [
        "GlassesLocal"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    },
    {
      "name" : "GlassesLocalVoice",
      "targets" : [
        "GlassesLocalVoice"
      ],
      "type" : {
        "library" : [
          "automatic"
        ]
      }
    }
  ],
  "targets" : [
    {
      "c99name" : "sherpaOnnxFFI",
      "module_type" : "BinaryTarget",
      "name" : "sherpaOnnxFFI",
      "path" : "remote/archive/sherpaOnnxFFI.xcframework.zip",
      "product_memberships" : [
        "GlassesLocalVoice"
      ],
      "sources" : [
      ],
      "type" : "binary"
    },
    {
      "c99name" : "onnxruntimeFFI",
      "module_type" : "BinaryTarget",
      "name" : "onnxruntimeFFI",
      "path" : "remote/archive/onnxruntimeFFI.xcframework.zip",
      "product_memberships" : [
        "GlassesLocalVoice"
      ],
      "sources" : [
      ],
      "type" : "binary"
    },
    {
      "c99name" : "extentos_coreFFI",
      "module_type" : "BinaryTarget",
      "name" : "extentos_coreFFI",
      "path" : "remote/archive/extentos_coreFFI.xcframework.zip",
      "product_memberships" : [
        "GlassesCore",
        "GlassesUI",
        "GlassesDebug",
        "GlassesLifecycle",
        "GlassesTesting",
        "GlassesLocal",
        "GlassesLocalVoice"
      ],
      "sources" : [
      ],
      "type" : "binary"
    },
    {
      "c99name" : "SherpaOnnxC",
      "module_type" : "ClangTarget",
      "name" : "SherpaOnnxC",
      "path" : "Sources/SherpaOnnxC",
      "product_memberships" : [
        "GlassesLocalVoice"
      ],
      "sources" : [
        "shim.c"
      ],
      "type" : "library"
    },
    {
      "c99name" : "GlassesUI",
      "module_type" : "SwiftTarget",
      "name" : "GlassesUI",
      "path" : "Sources/GlassesUI",
      "product_memberships" : [
        "GlassesUI"
      ],
      "sources" : [
        "Appearance.swift",
        "ConnectionPageJsonConfig.swift",
        "EscapeHatch.swift",
        "ExtentosConnectionPage.swift",
        "ExtentosPairingScreen.swift",
        "ExtentosTheme.swift"
      ],
      "target_dependencies" : [
        "GlassesCore"
      ],
      "type" : "library"
    },
    {
      "c99name" : "GlassesTesting",
      "module_type" : "SwiftTarget",
      "name" : "GlassesTesting",
      "path" : "Sources/GlassesTesting",
      "product_memberships" : [
        "GlassesTesting"
      ],
      "sources" : [
        "FakeExtentosGlasses.swift"
      ],
      "target_dependencies" : [
        "GlassesCore"
      ],
      "type" : "library"
    },
    {
      "c99name" : "GlassesLocalVoice",
      "module_type" : "SwiftTarget",
      "name" : "GlassesLocalVoice",
      "path" : "Sources/GlassesLocalVoice",
      "product_memberships" : [
        "GlassesLocalVoice"
      ],
      "sources" : [
        "KokoroModelDownload.swift",
        "KokoroModelManifest.swift",
        "KokoroServingProbe.swift",
        "KokoroSynthesizer.swift"
      ],
      "target_dependencies" : [
        "GlassesCore",
        "SherpaOnnxC",
        "sherpaOnnxFFI",
        "onnxruntimeFFI"
      ],
      "type" : "library"
    },
    {
      "c99name" : "GlassesLocal",
      "module_type" : "SwiftTarget",
      "name" : "GlassesLocal",
      "path" : "Sources/GlassesLocal",
      "product_dependencies" : [
        "MLXLLM",
        "MLXLMCommon",
        "MLXHuggingFace",
        "HuggingFace",
        "Tokenizers"
      ],
      "product_memberships" : [
        "GlassesLocal"
      ],
      "sources" : [
        "AutoModelSelection.swift",
        "ExtentosLocalTier.swift",
        "LocalBrain.swift"
      ],
      "target_dependencies" : [
        "GlassesCore"
      ],
      "type" : "library"
    },
    {
      "c99name" : "GlassesLifecycle",
      "module_type" : "SwiftTarget",
      "name" : "GlassesLifecycle",
      "path" : "Sources/GlassesLifecycle",
      "product_memberships" : [
        "GlassesLifecycle"
      ],
      "sources" : [
        "ListeningModifier.swift"
      ],
      "target_dependencies" : [
        "GlassesCore"
      ],
      "type" : "library"
    },
    {
      "c99name" : "GlassesDebug",
      "module_type" : "SwiftTarget",
      "name" : "GlassesDebug",
      "path" : "Sources/GlassesDebug",
      "product_memberships" : [
        "GlassesDebug"
      ],
      "sources" : [
        "ExtentosDebugPanel.swift"
      ],
      "target_dependencies" : [
        "GlassesCore"
      ],
      "type" : "library"
    },
    {
      "c99name" : "GlassesCore",
      "module_type" : "SwiftTarget",
      "name" : "GlassesCore",
      "path" : "Sources/GlassesCore",
      "product_dependencies" : [
        "MWDATCore",
        "MWDATCamera",
        "MWDATDisplay"
      ],
      "product_memberships" : [
        "GlassesCore",
        "GlassesUI",
        "GlassesDebug",
        "GlassesLifecycle",
        "GlassesTesting",
        "GlassesLocal",
        "GlassesLocalVoice"
      ],
      "sources" : [
        "Assistant/AssistantClient.swift",
        "Assistant/AssistantConfig.swift",
        "Assistant/AssistantEvent.swift",
        "Assistant/AssistantProvider.swift",
        "Assistant/Tool.swift",
        "Assistant/Turn.swift",
        "AudioClient.swift",
        "CameraClient.swift",
        "Conformances.swift",
        "ConnectionClient.swift",
        "Device.swift",
        "DisplayClient.swift",
        "Errors.swift",
        "Events/EventLogger.swift",
        "Extentos.swift",
        "ExtentosConfig.swift",
        "ExtentosSceneObserver.swift",
        "Generated/extentos_core.swift",
        "Impl/AssistantConfigClient.swift",
        "Impl/AssistantTransportBridge.swift",
        "Impl/AttestClient.swift",
        "Impl/DefaultAssistantClient.swift",
        "Impl/DefaultAudioClient.swift",
        "Impl/DefaultCameraClient.swift",
        "Impl/DefaultConnectionClient.swift",
        "Impl/DefaultDisplayClient.swift",
        "Impl/DefaultExtentosGlasses.swift",
        "Impl/DefaultObservabilityClient.swift",
        "Impl/DefaultRuntimeClient.swift",
        "Impl/DefaultTelemetryClient.swift",
        "Impl/DefaultToggleClient.swift",
        "Impl/DefaultVoiceClient.swift",
        "Impl/DeviceInstallStore.swift",
        "Impl/EnvironmentClassifier.swift",
        "Impl/HostedLocalBrain.swift",
        "Impl/LocalRealtimeProvider.swift",
        "Impl/LocalTierDiagnostics.swift",
        "Impl/LocalVoiceRegistry.swift",
        "Impl/MediaDelivery.swift",
        "Impl/MockAssistantProvider.swift",
        "Impl/MutableState.swift",
        "Impl/PersistentMemoryStore.swift",
        "Impl/RealtimeCoreProvider.swift",
        "Impl/StoreProof.swift",
        "Impl/TelemetryBridge.swift",
        "Impl/VoiceTransportBridge.swift",
        "JSONValue.swift",
        "LibraryVersion.swift",
        "MigratedCoreTypes.swift",
        "ObservabilityClient.swift",
        "ObservableState.swift",
        "PhotoExtensions.swift",
        "PushToTalkSession.swift",
        "Runtime/AudioCaptureSession.swift",
        "Runtime/EarsMeter.swift",
        "Runtime/EarsTape.swift",
        "Runtime/EarsTuning.swift",
        "Runtime/Mp4Structure.swift",
        "Runtime/PlatformSttEngine.swift",
        "Runtime/SharedAudioInput.swift",
        "Runtime/VideoCaptureSession.swift",
        "Runtime/WakeLedger.swift",
        "RuntimeClient.swift",
        "TelemetryClient.swift",
        "ToggleClient.swift",
        "Transport/Brilliant/BleAudioInput.swift",
        "Transport/Brilliant/BrilliantTransport.swift",
        "Transport/Brilliant/CoreBluetoothBleBridge.swift",
        "Transport/Brilliant/ExtentosBrilliant.swift",
        "Transport/BrowserSimTransport.swift",
        "Transport/GlassesTransport.swift",
        "Transport/LocalSimTransport.swift",
        "Transport/MWDATBridge.swift",
        "Transport/MetaDisplayTranslation.swift",
        "Transport/MetaHardwareBridge.swift",
        "Transport/RealMetaTransport.swift",
        "Transport/SpeechDelegateBox.swift",
        "Transport/SystemAudioBridge.swift",
        "Transport/SystemAudioHardwareBridge.swift",
        "Transport/SystemAudioTransport.swift",
        "Transport/VendorTransports.swift",
        "Transport/YuvPacking.swift",
        "UiState.swift",
        "VoiceClient.swift"
      ],
      "target_dependencies" : [
        "extentos_coreFFI"
      ],
      "type" : "library"
    }
  ],
  "tools_version" : "6.0"
}
Done.