v1 to git:20260814.a9c26d7
81 added, 494 removed. Audit A to A.
---
name: SpeechAnalyzer Framework Expert
- description: Expert guide for Apple's modern Speech framework (macOS 26+, iOS 26+) featuring SpeechAnalyzer and SpeechTranscriber for on-device speech-to-text transcription.
- version: 1.0
- activation: Activate for queries on Speech framework, SpeechAnalyzer, SpeechTranscriber, on-device speech recognition, audio transcription, or migrating from WhisperKit/SFSpeechRecognizer.
+ description: Implement, migrate, debug, and review on-device transcription with Apple SpeechAnalyzer, SpeechTranscriber, DictationTranscriber, AssetInventory, AnalyzerInput, live microphone audio, and audio-file analysis on iOS 26, macOS 26, visionOS 26, and tvOS 26 where supported. Use for SpeechAnalyzer setup, locale assets and reservations, volatile/final results, AttributedString transcripts, audio conversion, permissions, lifecycle, and migration from SFSpeechRecognizer or Whisper-based solutions. Do not invent beta or later-SDK APIs, assume locale/device support, iterate Foundation Progress as an AsyncSequence, or use SpeechAnalyzer on watchOS.
---
- # SpeechAnalyzer Framework Expert
-
- This skill provides comprehensive guidance on implementing Apple's modern Speech framework introduced for macOS 26+ and iOS 26+. The framework features `SpeechAnalyzer` and `SpeechTranscriber` for on-device speech-to-text transcription, offering 2.2x faster performance than Whisper Large V3 Turbo with out-of-process execution and automatic system updates.
-
- ## Best Practices
-
- 1. **Always allocate locale after model download**: Call `transcriber.allocate(locale:)` only after downloading assets via `AssetInventory.assetInstallationRequest()` to avoid "Cannot use modules with unallocated locales" errors.
-
- 2. **Use proper audio format conversion**: Convert audio buffers to the analyzer's required format using `AVAudioConverter` with `primeMethod = .none` to prevent timestamp drift.
-
- 3. **Follow the complete setup sequence**: Instantiate transcriber → download models → allocate locale → create analyzer → get best format → create AsyncStream → start analyzer → consume results. Skipping steps causes runtime errors.
-
- 4. **Leverage out-of-process execution**: The framework runs transcription in a separate process, eliminating memory limits in your app and providing automatic system updates without app redeployment.
-
- 5. **Handle both volatile and final results**: Process `result.isFinal` to distinguish between live transcription updates (volatile) and completed segments (final) for proper UI updates.
-
- 6. **Check locale support before use**: Use `SpeechTranscriber.supportedLocales` and `installedLocales` to verify language availability before creating transcriber instances.
-
- 7. **Implement proper AsyncStream lifecycle management**: Create input streams with `AsyncStream<AnalyzerInput>.makeStream()` and properly yield converted buffers to the continuation for reliable transcription.
-
- 8. **Use structured concurrency patterns**: Leverage async/await and actor isolation for thread-safe transcription state management and result processing.
-
- 9. **Monitor asset installation progress**: Track download progress for large language models to provide user feedback during initial setup.
-
- 10. **Handle transcription errors gracefully**: Catch and handle errors from `analyzer.start()` and result iteration to provide fallback behavior when transcription fails.
-
- ## Speech Framework Guidelines
-
- - Use `SpeechAnalyzer` as the main coordinator, passing an array of modules like `[SpeechTranscriber]`
- - Always get the best audio format with `SpeechAnalyzer.bestAvailableAudioFormat(compatibleWith:)` before processing
- - Feed audio as `AnalyzerInput` objects containing converted `AVAudioPCMBuffer` instances
- - Consume transcription results as `AsyncSequence` using `for try await result in transcriber.results`
- - Support 10+ languages including English, Spanish, French, German, Italian, Japanese, Korean, Portuguese, Russian, Chinese
- - Prefer on-device transcription for privacy-sensitive applications
- - Use `reportingOptions: [.volatileResults]` for real-time live captioning
- - Include `attributeOptions: [.audioTimeRange]` for precise word-level timing information
- - Implement proper cleanup by canceling tasks and releasing analyzer references
-
- ## Examples
-
- ### Example 1: Basic SpeechAnalyzer Setup
-
- **User Prompt:** "Show me how to set up SpeechAnalyzer with SpeechTranscriber for English transcription."
-
- **Expected Output:**
- ```swift
- import Speech
-
- @MainActor
- class TranscriptionManager {
- private var transcriber: SpeechTranscriber?
- private var analyzer: SpeechAnalyzer?
- private var inputContinuation: AsyncStream<AnalyzerInput>.Continuation?
-
- func setupTranscription() async throws {
- let locale = Locale(identifier: "en-US")
-
- // Step 1: Create transcriber
- let transcriber = SpeechTranscriber(
- locale: locale,
- transcriptionOptions: [],
- reportingOptions: [.volatileResults],
- attributeOptions: [.audioTimeRange]
- )
-
- // Step 2: Download model if needed
- if let request = try await AssetInventory.assetInstallationRequest(
- supporting: [transcriber]
- ) {
- try await request.downloadAndInstall()
- }
-
- // Step 3: CRITICAL - Allocate locale AFTER download
- try await transcriber.allocate(locale: locale)
-
- // Step 4: Create analyzer
- let analyzer = SpeechAnalyzer(modules: [transcriber])
-
- // Step 5: Get best format
- let format = await SpeechAnalyzer.bestAvailableAudioFormat(
- compatibleWith: [transcriber]
- )
- print("Best format: \(format)")
-
- // Step 6: Create AsyncStream for input
- let (inputSequence, inputBuilder) = AsyncStream<AnalyzerInput>.makeStream()
- self.inputContinuation = inputBuilder
-
- // Step 7: Start analyzer
- try await analyzer.start(inputSequence: inputSequence)
-
- // Store references
- self.transcriber = transcriber
- self.analyzer = analyzer
-
- // Step 8: Start consuming results
- Task {
- for try await result in transcriber.results {
- if result.isFinal {
- print("Final: \(result.transcription)")
- } else {
- print("Live: \(result.transcription)")
- }
- }
- }
- }
- }
- ```
-
- ### Example 2: Audio Buffer Conversion
-
- **User Prompt:** "How do I convert AVAudioPCMBuffer to the format required by SpeechAnalyzer?"
-
- **Expected Output:**
- ```swift
- import AVFoundation
- import Speech
-
- class BufferConverter {
- private var converter: AVAudioConverter?
-
- func convertBuffer(_ buffer: AVAudioPCMBuffer,
- to format: AVAudioFormat) throws -> AVAudioPCMBuffer {
- // Create converter if needed or format changed
- if converter == nil || converter?.outputFormat != format {
- converter = AVAudioConverter(from: buffer.format, to: format)
- // CRITICAL: Prevents timestamp drift
- converter?.primeMethod = .none
- }
-
- guard let converter = converter else {
- throw ConversionError.converterCreationFailed
- }
-
- // Calculate output frame capacity
- let ratio = format.sampleRate / buffer.format.sampleRate
- let outputFrameCapacity = AVAudioFrameCount(ceil(Double(buffer.frameLength) * ratio))
-
- guard let outputBuffer = AVAudioPCMBuffer(
- pcmFormat: format,
- frameCapacity: outputFrameCapacity
- ) else {
- throw ConversionError.bufferAllocationFailed
- }
-
- var error: NSError?
- let status = converter.convert(to: outputBuffer, error: &error) { inPackets, outStatus in
- outStatus.pointee = .haveData
- return buffer
- }
-
- guard status != .error, error == nil else {
- throw ConversionError.conversionFailed(error)
- }
-
- return outputBuffer
- }
-
- enum ConversionError: Error {
- case converterCreationFailed
- case bufferAllocationFailed
- case conversionFailed(Error?)
- }
- }
- ```
-
- ### Example 3: Complete Microphone Transcription
-
- **User Prompt:** "Create a complete example that captures microphone audio and transcribes it in real-time."
-
- **Expected Output:**
- ```swift
- import AVFoundation
- import Speech
- import SwiftUI
-
- @MainActor
- @Observable
- class LiveTranscriptionManager {
- var liveText: String = ""
- var finalText: String = ""
- var isRecording = false
-
- private var transcriber: SpeechTranscriber?
- private var analyzer: SpeechAnalyzer?
- private var audioEngine: AVAudioEngine?
- private var inputContinuation: AsyncStream<AnalyzerInput>.Continuation?
- private var bufferConverter = BufferConverter()
- private var analyzerFormat: AVAudioFormat?
-
- func startTranscription() async throws {
- let locale = Locale(identifier: "en-US")
-
- // Setup transcriber and analyzer
- let transcriber = SpeechTranscriber(
- locale: locale,
- transcriptionOptions: [],
- reportingOptions: [.volatileResults],
- attributeOptions: [.audioTimeRange]
- )
-
- // Download model if needed
- if let request = try await AssetInventory.assetInstallationRequest(
- supporting: [transcriber]
- ) {
- try await request.downloadAndInstall()
- }
-
- // Allocate locale
- try await transcriber.allocate(locale: locale)
-
- // Create analyzer
- let analyzer = SpeechAnalyzer(modules: [transcriber])
-
- // Get best format
- let format = await SpeechAnalyzer.bestAvailableAudioFormat(
- compatibleWith: [transcriber]
- )
- self.analyzerFormat = format
-
- // Create input stream
- let (inputSequence, inputBuilder) = AsyncStream<AnalyzerInput>.makeStream()
- self.inputContinuation = inputBuilder
-
- // Start analyzer
- try await analyzer.start(inputSequence: inputSequence)
-
- self.transcriber = transcriber
- self.analyzer = analyzer
-
- // Start consuming results
- Task {
- for try await result in transcriber.results {
- if result.isFinal {
- self.finalText += result.transcription + " "
- self.liveText = ""
- } else {
- self.liveText = result.transcription
- }
- }
- }
-
- // Setup audio engine
- try setupAudioEngine()
-
- isRecording = true
- }
-
- private func setupAudioEngine() throws {
- let audioEngine = AVAudioEngine()
- let inputNode = audioEngine.inputNode
- let inputFormat = inputNode.outputFormat(forBus: 0)
-
- inputNode.installTap(onBus: 0, bufferSize: 4096, format: inputFormat) { [weak self] buffer, time in
- guard let self = self,
- let analyzerFormat = self.analyzerFormat else { return }
-
- do {
- // Convert buffer to analyzer format
- let convertedBuffer = try self.bufferConverter.convertBuffer(
- buffer,
- to: analyzerFormat
- )
-
- // Feed to analyzer
- let input = AnalyzerInput(buffer: convertedBuffer)
- self.inputContinuation?.yield(input)
- } catch {
- print("Buffer conversion error: \(error)")
- }
- }
-
- audioEngine.prepare()
- try audioEngine.start()
- self.audioEngine = audioEngine
- }
+ # SpeechAnalyzer Framework
- func stopTranscription() {
- audioEngine?.stop()
- audioEngine?.inputNode.removeTap(onBus: 0)
- inputContinuation?.finish()
+ Use the API surface in the project’s installed SDK. This guide is compatibility-first for the stable Xcode 26.6 / iOS 26.5 SDK and does not substitute later beta conveniences into a 26-target implementation.
- audioEngine = nil
- analyzer = nil
- transcriber = nil
- isRecording = false
- }
- }
+ ## Compatibility baseline
- // SwiftUI View
- struct LiveTranscriptionView: View {
- @State private var manager = LiveTranscriptionManager()
+ - `SpeechAnalyzer`, `SpeechTranscriber`, `AssetInventory`, and `AnalyzerInput` require iOS 26, macOS 26, visionOS 26, or tvOS 26. They are unavailable on watchOS.
+ - `DictationTranscriber` is available on iOS 26, macOS 26, and visionOS 26, but not tvOS/watchOS.
+ - Build these APIs with Xcode 26 or newer. A lower deployment target requires an availability gate and a legacy or disabled-feature path.
+ - `SpeechTranscriber.isAvailable` is hardware-sensitive. An OS version check alone is insufficient.
+ - The live microphone example is iOS-only because it configures `AVAudioSession` and requests record permission.
+ - If an SDK 27 beta offers helpers such as capture/input providers or converter types, keep those declarations in a beta-SDK-only source path, add the relevant `#available(iOS 27, macOS 27, ...)` runtime gate, and retain the 26 implementation. A stable 26 compiler cannot resolve an unknown symbol merely because it appears inside `#available`.
- var body: some View {
- VStack(spacing: 20) {
- Text("Live Transcription")
- .font(.title)
+ Do not hardcode a language count. Query locale support on the running device.
- ScrollView {
- VStack(alignment: .leading, spacing: 10) {
- if !manager.finalText.isEmpty {
- Text(manager.finalText)
- .foregroundColor(.primary)
- }
- if !manager.liveText.isEmpty {
- Text(manager.liveText)
- .foregroundColor(.secondary)
- .italic()
- }
- }
- .frame(maxWidth: .infinity, alignment: .leading)
- .padding()
- }
- .frame(maxHeight: 300)
- .background(Color(.systemGray6))
- .cornerRadius(10)
+ ## Stable setup sequence
- Button(manager.isRecording ? "Stop" : "Start Recording") {
- Task {
- if manager.isRecording {
- manager.stopTranscription()
- } else {
- try? await manager.startTranscription()
- }
- }
- }
- .buttonStyle(.borderedProminent)
- }
- .padding()
- }
- }
- ```
+ 1. Check `SpeechTranscriber.isAvailable`.
+ 2. Resolve user input with `SpeechTranscriber.supportedLocale(equivalentTo:)`; exact `Locale` equality can reject a usable regional equivalent.
+ 3. Reserve the resolved locale with `AssetInventory.reserve(locale:)` when the app owns that reservation.
+ 4. Create a transcriber for the resolved locale.
+ 5. Obtain `AssetInventory.assetInstallationRequest(supporting:)` and await `downloadAndInstall()` when it returns a request.
+ 6. Guard the optional result of `SpeechAnalyzer.bestAvailableAudioFormat(compatibleWith:)` before installing an audio path.
+ 7. Create `SpeechAnalyzer`, supply `AnalyzerInput` values, and consume `transcriber.results` in tracked structured work.
+ 8. End input and await an analyzer finish method. Finishing an `AsyncStream` alone does not finish analysis.
+ 9. Await the result consumer, then release only the locale reservation this operation created.
- ### Example 4: Locale Management and Model Download
+ There is no `SpeechTranscriber.allocate(locale:)` in the stable 26 SDK. Locale reservation is an `AssetInventory` responsibility.
- **User Prompt:** "How do I check which languages are supported and download models for a specific locale?"
+ Read [examples/basic_setup.swift](examples/basic_setup.swift) for a scoped preparation helper that releases its reservation on success and failure.
- **Expected Output:**
- ```swift
- import Speech
+ ## Assets and progress
- @MainActor
- class LocaleManager {
- func checkAndDownloadLocale(_ localeIdentifier: String) async throws -> Bool {
- let locale = Locale(identifier: localeIdentifier)
+ `AssetInventory.reserve(locale:)` returns `true` when it created a new app reservation and `false` when that locale was already reserved. Release only reservations the current owner created; do not tear down another feature’s reservation. Respect `maximumReservedLocales` and expose an explicit release action.
- // Check if locale is supported
- let supported = await SpeechTranscriber.supportedLocales
- guard supported.contains(locale) else {
- print("Locale \(localeIdentifier) is not supported")
- return false
- }
+ `AssetInstallationRequest` conforms to `ProgressReporting`. Its `progress` property is Foundation `Progress`, not an `AsyncSequence`. Pass the object to UI/observation code or inspect `fractionCompleted`; never write `for try await` over it.
- // Check if already installed
- let installed = await SpeechTranscriber.installedLocales
- if installed.contains(locale) {
- print("Locale \(localeIdentifier) is already installed")
- return true
- }
+ Read [examples/locale_manager.swift](examples/locale_manager.swift) for equivalence lookup, explicit reservation ownership, installation, Foundation Progress handoff, and release.
- // Create temporary transcriber to check requirements
- let transcriber = SpeechTranscriber(
- locale: locale,
- transcriptionOptions: [],
- reportingOptions: [],
- attributeOptions: []
- )
+ ## Results
- // Request installation
- if let request = try await AssetInventory.assetInstallationRequest(
- supporting: [transcriber]
- ) {
- print("Downloading models for \(localeIdentifier)...")
+ The element type is `SpeechTranscriber.Result`. Use:
- // Monitor progress (optional)
- Task {
- for try await progress in request.progress {
- print("Download progress: \(progress.fractionCompleted * 100)%")
- }
- }
+ - `result.text` for the most likely `AttributedString`;
+ - `String(result.text.characters)` when plain text is required;
+ - `result.alternatives` only when alternative reporting was configured;
+ - `result.isFinal` to distinguish final from volatile output;
+ - `result.range` and configured attributes when reconciling time-indexed text.
- try await request.downloadAndInstall()
- print("Installation complete")
- return true
- }
+ There is no `SpeechTranscriptionResult` type and no `result.transcription` property in the stable 26 SDK.
- return true // Already available
- }
+ When volatile reporting is enabled, replace the current volatile segment rather than repeatedly appending it. Append finalized text once. For editors that can receive overlapping ranges, reconcile by `result.range` instead of assuming a single volatile phrase.
- func listAvailableLocales() async {
- let supported = await SpeechTranscriber.supportedLocales
- let installed = await SpeechTranscriber.installedLocales
+ Read [examples/error_handling.swift](examples/error_handling.swift) for typed validation errors and correct result accumulation.
- print("Supported locales:")
- for locale in supported {
- let status = installed.contains(locale) ? "✓ Installed" : "⬇ Available"
- print(" \(locale.identifier) - \(status)")
- }
- }
- }
- ```
+ ## Lifecycle and concurrency
- ### Example 5: Error Handling and Recovery
+ - Store any unstructured result-consumer task and cancel/await it during teardown. Prefer `async let` or a task group for finite file transcription.
+ - After ending input, call `finalizeAndFinishThroughEndOfInput()` to drain and finalize, or `cancelAndFinishNow()` when results are no longer needed.
+ - Propagate setup and finite-analysis errors to the awaiting caller. Surface later live-stream failures through explicit state/callbacks rather than throwing inside an unobserved task.
+ - Guard concurrent starts while permission prompts or model installation are pending.
+ - Keep audio callbacks away from `MainActor` state. Capture a dedicated synchronized feeder and hop to the main actor only for UI/error delivery.
+ - Do not mark AVFoundation types `@unchecked Sendable` without a concrete synchronization/ownership invariant.
- **User Prompt:** "What are common errors when using SpeechAnalyzer and how do I handle them?"
+ ## Live microphone transcription
- **Expected Output:**
- ```swift
- import Speech
+ An iOS host app needs both:
- @MainActor
- class RobustTranscriptionManager {
- private var transcriber: SpeechTranscriber?
- private var analyzer: SpeechAnalyzer?
+ - `NSSpeechRecognitionUsageDescription`
+ - `NSMicrophoneUsageDescription`
- enum TranscriptionError: Error {
- case localeNotAllocated
- case analyzerStartFailed
- case modelNotDownloaded
- case audioFormatMismatch
- case transcriptionFailed(Error)
+ Request speech and microphone authorization before starting the engine. Configure and activate the app’s `AVAudioSession` according to the broader audio policy; the sample owns a record-only measurement session and deactivates it on stop. Apps that mix playback, calls, or other recorders need a central session coordinator.
- var userMessage: String {
- switch self {
- case .localeNotAllocated:
- return "Language not initialized. Please try again."
- case .analyzerStartFailed:
- return "Failed to start transcription service."
- case .modelNotDownloaded:
- return "Language model needs to be downloaded first."
- case .audioFormatMismatch:
- return "Audio format is incompatible with transcription."
- case .transcriptionFailed(let error):
- return "Transcription error: \(error.localizedDescription)"
- }
- }
- }
+ Install the tap only after obtaining a nonoptional analyzer format. Remove the tap, stop the engine, finish input, finalize/cancel the analyzer, await the result task, deactivate the session, and release the owned reservation on every stop/failure path.
- func safeSetupTranscription(locale: Locale) async throws {
- do {
- // Step 1: Verify locale support
- let supported = await SpeechTranscriber.supportedLocales
- guard supported.contains(locale) else {
- throw TranscriptionError.modelNotDownloaded
- }
+ Read these two files together:
- // Step 2: Create transcriber
- let transcriber = SpeechTranscriber(
- locale: locale,
- transcriptionOptions: [],
- reportingOptions: [.volatileResults],
- attributeOptions: [.audioTimeRange]
- )
+ - [examples/live_transcription.swift](examples/live_transcription.swift): permissions, audio session, engine, tracked task, finalization, and reservation lifecycle.
+ - [examples/buffer_converter.swift](examples/buffer_converter.swift): synchronized converter recreation when either input or output format changes.
- // Step 3: Download model with error handling
- if let request = try await AssetInventory.assetInstallationRequest(
- supporting: [transcriber]
- ) {
- do {
- try await request.downloadAndInstall()
- } catch {
- throw TranscriptionError.modelNotDownloaded
- }
- }
+ The sample feeder performs bounded conversion in the audio tap and never touches UI-isolated state. Profile this path on supported devices. A production recorder with stricter real-time requirements should use a preallocated/ring-buffer architecture appropriate to its latency budget.
- // Step 4: Allocate locale with retry
- do {
- try await transcriber.allocate(locale: locale)
- } catch {
- // Common error: "Cannot use modules with unallocated locales"
- throw TranscriptionError.localeNotAllocated
- }
+ ## Audio-file transcription
- // Step 5: Create analyzer
- let analyzer = SpeechAnalyzer(modules: [transcriber])
+ File analysis does not need microphone permission or an iOS audio session. Prepare assets, open `AVAudioFile`, start analysis with `finishAfterFile: true`, and consume results with structured concurrency.
- // Step 6: Get format and validate
- let format = await SpeechAnalyzer.bestAvailableAudioFormat(
- compatibleWith: [transcriber]
- )
- guard format.sampleRate > 0 else {
- throw TranscriptionError.audioFormatMismatch
- }
+ Read [examples/file_transcription.swift](examples/file_transcription.swift). Invoke it inside `withPreparedSpeechTranscriber` from the basic example so reservation ownership stays scoped.
- // Step 7: Create input stream
- let (inputSequence, _) = AsyncStream<AnalyzerInput>.makeStream()
+ ## Fallback and migration
- // Step 8: Start analyzer with error handling
- do {
- try await analyzer.start(inputSequence: inputSequence)
- } catch {
- throw TranscriptionError.analyzerStartFailed
- }
+ - If `SpeechTranscriber.isAvailable` is false, disable the feature or evaluate `DictationTranscriber` on supported platforms and query its locale support separately.
+ - Keep `SFSpeechRecognizer` only behind a deliberate lower-OS or feature-gap adapter; its authorization, request, result, and network behavior differ.
+ - Treat migration from Whisper as a product decision: verify supported locale, device hardware, offline behavior, timestamps, custom vocabulary, model/storage policy, latency, and quality on representative audio.
+ - Out-of-process models reduce model memory in the app process; they do not eliminate the app’s memory limits or the cost of buffers, transcript state, and tasks.
- self.transcriber = transcriber
- self.analyzer = analyzer
+ ## Review checklist
- // Step 9: Consume results with error handling
- Task {
- do {
- for try await result in transcriber.results {
- processResult(result)
- }
- } catch {
- print("Result iteration error: \(error)")
- throw TranscriptionError.transcriptionFailed(error)
- }
- }
+ - Deployment target, SDK, device availability, and locale equivalence are checked.
+ - Only stable installed APIs are used on the 26 path.
+ - A created reservation is released; an existing shared reservation is preserved.
+ - `Progress` is observed as Foundation Progress.
+ - Optional audio format is guarded.
+ - Results use `SpeechTranscriber.Result.text` and preserve `AttributedString` when useful.
+ - Input finish is followed by analyzer finalization/cancellation.
+ - Result work is stored or structured and all errors have an owner.
+ - Live capture includes usage descriptions, permission requests, session activation/deactivation, tap removal, and repeated-start protection.
+ - Audio conversion handles route/input-format changes and does not access main-actor UI state from the tap.
- } catch let error as TranscriptionError {
- print("Transcription setup failed: \(error.userMessage)")
- throw error
- } catch {
- print("Unexpected error: \(error)")
- throw TranscriptionError.transcriptionFailed(error)
- }
- }
+ ## Supporting material
- private func processResult(_ result: SpeechTranscriptionResult) {
- // Process transcription result
- if result.isFinal {
- print("Final: \(result.transcription)")
- } else {
- print("Volatile: \(result.transcription)")
- }
- }
- }
- ```
+ - [README.md](README.md) summarizes platforms and integration requirements.
+ - [examples/basic_setup.swift](examples/basic_setup.swift) scopes model preparation and reservation release.
+ - [examples/locale_manager.swift](examples/locale_manager.swift) manages locale assets and Progress.
+ - [examples/error_handling.swift](examples/error_handling.swift) handles results and validation failures.
+ - [examples/file_transcription.swift](examples/file_transcription.swift) performs finite file analysis.
+ - [examples/live_transcription.swift](examples/live_transcription.swift) and [examples/buffer_converter.swift](examples/buffer_converter.swift) form the live iOS example.
+ - [examples/prompts.md](examples/prompts.md) contains representative activation prompts.