Swift Package IndexBuild Information
Failed to build Choir, reference main (2c8de8), with Swift 6.3 for Wasm on 15 Sep 2026 07:30:55 UTC.
Build Command
bash -c docker run --pull=always --rm -v "checkouts-53886770-2":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3.2-RELEASE_wasm 2>&1Build Log
========================================
RunAll
========================================
Builder version: 5.0.2
Interrupt handler set up.
========================================
Checkout
========================================
Clone URL: https://github.com/halalchristiano/Choir.git
Reference: main
Initialized empty Git repository in /host/spi-builder-workspace/.git/
hint: Using 'master' as the name for the initial branch. This default branch name
hint: is subject to change. To configure the initial branch name to use in all
hint: of your new repositories, which will suppress this warning, call:
hint:
hint: git config --global init.defaultBranch <name>
hint:
hint: Names commonly chosen instead of 'master' are 'main', 'trunk' and
hint: 'development'. The just-created branch can be renamed via this command:
hint:
hint: git branch -m <name>
From https://github.com/halalchristiano/Choir
* branch main -> FETCH_HEAD
* [new branch] main -> origin/main
HEAD is now at 2c8de8a Add voice packs, consent for real-person voices, and faster transcription
Cloned https://github.com/halalchristiano/Choir.git
Revision (git rev-parse @):
2c8de8affcda6811dff9603419413059dc0616d9
SPI manifest file found: $PWD/.spi.yml
SUCCESS checkout https://github.com/halalchristiano/Choir.git at main
========================================
Build
========================================
Selected platform: wasm
Swift version: 6.3
Building package at path: $PWD
https://github.com/halalchristiano/Choir.git
Running build ...
bash -c docker run --pull=always --rm -v "checkouts-53886770-2":/host -w "$PWD" -e JAVA_HOME="/root/.sdkman/candidates/java/current" -e SPI_BUILD="1" -e SPI_PROCESSING="1" registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest swift build --swift-sdk swift-6.3.2-RELEASE_wasm 2>&1
wasm-6.3-latest: Pulling from saguaro1/spi-images
Digest: sha256:253aad7f5b11d25cf9eaef34120b94cd8a325782929c57fb304a7711494a3f9a
Status: Image is up to date for registry.gitlab.com/saguaro1/spi-images:wasm-6.3-latest
Building for debugging...
[0/9] Copying CMUDICT-LICENSE.txt
[0/9] Write sources
[3/9] Copying cmudict.lex
[4/9] Write swift-version-24593BA9C3E375BF.txt
[6/69] Compiling Choir ToBI.swift
[7/69] Compiling Choir HarvardSentences.swift
[8/69] Compiling Choir IntelligibilityHarness.swift
[9/69] Compiling Choir ListeningEvaluation.swift
[10/69] Compiling Choir TranscriptionScoring.swift
[11/69] Compiling Choir Cancellation.swift
[12/69] Compiling Choir RealTimeController.swift
[13/69] Compiling Choir SeededGenerator.swift
[14/77] Compiling Choir ChoirTierOne.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[15/77] Compiling Choir AudioBuffer.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[16/77] Compiling Choir AudioEffectChain.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[17/77] Compiling Choir AudioEncoder.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[18/77] Compiling Choir AudioFilters.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[19/77] Compiling Choir AudioMastering.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[20/77] Compiling Choir FloatAudioBuffer.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[21/77] Compiling Choir TimelineAudioExporter.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[22/77] Compiling Choir VoiceQualityMetrics.swift
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:49:52: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
47 | for file in audioFiles {
48 | let url = directory.appendingPathComponent(file.name, isDirectory: false)
49 | try file.data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
50 | written.append(url)
51 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/AudioOutput/TimelineAudioExporter.swift:59:47: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
57 | for (name, data) in artifacts {
58 | let url = directory.appendingPathComponent(name, isDirectory: false)
59 | try data.write(to: url, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
60 | written.append(url)
61 | }
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[23/77] Compiling Choir BenchmarkHarness.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[24/77] Compiling Choir ReferenceDevice.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[25/77] Compiling Choir AssetCache.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[26/77] Compiling Choir LazyAssetStore.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[27/77] Compiling Choir SynthesisAudioCache.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[28/77] Compiling Choir Choir.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[29/77] Compiling Choir Errors.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[30/77] Compiling Choir SHA256.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[31/77] Compiling Choir SynthesisParameters.swift
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:458:21: error: cannot find 'DispatchTime' in scope
456 | /// PRF-011: a fresh engine, including any lazy loading, to first audio.
457 | private func measureColdStart(voice: Voice) async -> Double {
458 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
459 | let engine = ChoirEngine()
460 | try? await engine.initialize()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:478:25: error: cannot find 'DispatchTime' in scope
476 |
477 | for _ in 0..<iterations {
478 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
479 | let audio = try? await engine.synthesize(text: Self.standardPassage, voice: voice)
480 | let elapsed = Self.secondsSince(start)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:497:25: error: cannot find 'DispatchTime' in scope
495 | private func measureLexiconLoad() -> [Double] {
496 | (0..<iterations).map { _ in
497 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
498 | let lexicon = BuiltInLexicon()
499 | lexicon.preload()
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:581:25: error: cannot find 'DispatchTime' in scope
579 | var samples: [Double] = []
580 | for _ in 0..<iterations {
581 | let start = DispatchTime.now()
| `- error: cannot find 'DispatchTime' in scope
582 | _ = try? await engine.synthesize(text: "A typical sentence for measurement.", voice: voice)
583 | samples.append(Self.secondsSince(start) * 1000)
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:607:16: error: cannot find 'DispatchTime' in scope
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
| `- error: cannot find 'DispatchTime' in scope
608 | }
609 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:404:70: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
402 | do {
403 | let destinationAudioURL = audioURL(for: record)
404 | try encoded.write(to: destinationAudioURL, options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
405 | try writeMetadata(record)
406 | if let existing, existing.isPinned != record.isPinned {
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:450:69: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
448 | record.isPinned = shouldPin
449 | record.lastAccess = nextAccessDate()
450 | try data.write(to: audioURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
451 | try writeMetadata(record)
452 | try? manager.removeItem(at: audioURL(for: oldRecord))
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
/host/spi-builder-workspace/Sources/Choir/Caching/SynthesisAudioCache.swift:602:82: error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
600 | let encoder = JSONEncoder()
601 | encoder.outputFormatting = [.sortedKeys]
602 | try encoder.encode(record).write(to: metadataURL(for: record), options: .atomic)
| `- error: 'atomic' is unavailable: atomic writing is unavailable in WASI because temporary files are not supported
603 | }
604 |
FoundationEssentials.Data.WritingOptions.atomic:4:23: note: 'atomic' has been explicitly marked unavailable here
2 | struct WritingOptions {
3 | @available(*, unavailable, message: "atomic writing is unavailable in WASI because temporary files are not supported")
4 | public static let atomic: Data.WritingOptions }
| `- note: 'atomic' has been explicitly marked unavailable here
5 | }
6 |
[32/77] Compiling Choir Voice.swift
[33/77] Compiling Choir VoiceBlending.swift
[34/77] Compiling Choir ChoirDemo.swift
[35/77] Compiling Choir FormantAcousticModel.swift
[36/77] Compiling Choir FormantSynthesis.swift
[37/77] Compiling Choir FormantTable.swift
[38/77] Compiling Choir FormantVocoder.swift
[39/77] Compiling Choir BuiltInLexicon.swift
[40/77] Compiling Choir G2PDiagnostics.swift
error: emit-module command failed with exit code 1 (use -v to see invocation)
[41/77] Emitting module Choir
/host/spi-builder-workspace/Sources/Choir/Benchmark/BenchmarkHarness.swift:606:47: error: cannot find type 'DispatchTime' in scope
604 | // MARK: - Platform helpers
605 |
606 | private static func secondsSince(_ start: DispatchTime) -> Double {
| `- error: cannot find type 'DispatchTime' in scope
607 | Double(DispatchTime.now().uptimeNanoseconds - start.uptimeNanoseconds) / 1_000_000_000
608 | }
[42/77] Compiling Choir PronunciationDictionary.swift
[43/77] Compiling Choir SSMLCParser.swift
[44/77] Compiling Choir ScriptureNormalizer.swift
[45/77] Compiling Choir SentenceSegmenter.swift
[46/77] Compiling Choir StressAssignment.swift
[47/77] Compiling Choir StressPredictor.swift
[48/77] Compiling Choir TextExpansions.swift
[49/77] Compiling Choir TextNormalizer.swift
[50/77] Compiling Choir G2PErrorAnalysis.swift
[51/77] Compiling Choir G2PEvaluation.swift
[52/77] Compiling Choir Heteronyms.swift
[53/77] Compiling Choir LinguisticFrontend.swift
[54/77] Compiling Choir NumberSpelling.swift
[55/77] Compiling Choir Phoneme.swift
[56/77] Compiling Choir PhonemeInventory.swift
[57/77] Compiling Choir Phonemizer.swift
[58/77] Compiling Choir TheologicalLexicon.swift
[59/77] Compiling Choir UserLexicon.swift
[60/77] Compiling Choir AcousticModel.swift
[61/77] Compiling Choir Vocoder.swift
[62/77] Compiling Choir VoicePack.swift
[63/77] Compiling Choir ContextualSpeechPlanner.swift
[64/77] Compiling Choir ProsodyFeatures.swift
[65/77] Compiling Choir ProsodyPredictor.swift
[66/77] Compiling Choir SynthesisEngine.swift
[67/77] Compiling Choir SynthesisInput.swift
[68/77] Compiling Choir SynthesisMetadata.swift
[69/77] Compiling Choir SynthesisPipeline.swift
[70/77] Compiling Choir SynthesisSession.swift
[71/77] Compiling Choir SampleVoice.swift
[72/77] Compiling Choir SimpleSynthesizer.swift
[73/77] Compiling Choir resource_bundle_accessor.swift
BUILD FAILURE 6.3 wasm