TOEFL Vocab: One Offline Vocabulary Trainer, Two Native Codebases, Neither Built Locally

static func weakness(_ stats: WordStats?,
                     weights: OrderingWeights = .default) -> Double {
    guard let stats, stats.attempts > 0 else { return unseenScore }

    // Smoothed so one wrong answer is not a 100% error rate forever.
    let smoothedErrorRate =
        (Double(stats.incorrect) + 0.5) / (Double(stats.attempts) + 1.0)
    var score = weights.errorWeight * smoothedErrorRate

    if stats.lastAnswerWasCorrect == false {
        score += weights.recentMistakeBonus
    }

    let streak = min(stats.consecutiveCorrect, weights.maximumStreakConsidered)
    score -= Double(streak) * weights.masteryPenaltyPerStreak

    let cycles = min(stats.completedCyclesThisRun, weights.maximumCyclesConsidered)
    score -= Double(cycles) * weights.completedCyclePenalty

    return score
}

// Records one self-graded answer and applies the five-step reset rule.
@discardableResult
mutating func record(correct isCorrect: Bool,
                     at date: Date = Date()) -> Bool {
    attempts += 1
    if isCorrect {
        correct += 1
        consecutiveCorrect += 1
    } else {
        incorrect += 1
        consecutiveCorrect = 0
    }
    lastAnsweredAt = date
    currentCycle.append(isCorrect)

    guard currentCycle.count >= Self.cycleLength else { return false }
    lastCycle = currentCycle
    currentCycle = []
    completedCycles += 1
    completedCyclesThisRun += 1
    return true
}

private static func voice(for accent: SpeechAccent) -> AVSpeechSynthesisVoice? {
    let matching = AVSpeechSynthesisVoice.speechVoices()
        .filter { $0.language == accent.localeIdentifier }

    if let enhanced = matching.first(where: { $0.quality == .enhanced }) {
        return enhanced
    }
    if let any = matching.first { return any }

    return AVSpeechSynthesisVoice(language: accent.localeIdentifier)
        ?? AVSpeechSynthesisVoice(language: "en-US")
}

// `.playback` so pronunciation still works with the ring/silent switch
// flipped to silent — a muted vocabulary app is a bug report.
// `.duckOthers` lowers the user's music instead of stopping it.
let session = AVAudioSession.sharedInstance()
try session.setCategory(.playback,
                        mode: .spokenAudio,
                        options: [.duckOthers])
try session.setActive(true)

@MainActor
static func apply(_ direction: LayoutDirection) {
    let attribute = attribute(for: direction)

    for scene in UIApplication.shared.connectedScenes {
        guard let windowScene = scene as? UIWindowScene else { continue }
        for window in windowScene.windows
        where window.semanticContentAttribute != attribute {
            window.semanticContentAttribute = attribute
            // The attribute alone marks the hierarchy dirty; this is
            // what makes already-visible views redraw in the new
            // direction instead of waiting for the next layout pass.
            window.subviews.forEach { $0.setNeedsLayout() }
        }
    }
}

RootView()
    .environment(\.strings, settings.strings)
    .environment(\.layoutDirection, layoutDirection)
    // Rebuild rather than re-lay-out on a language change.
    .id(language)
    .preferredColorScheme(settings.settings.theme.colorScheme)
    // Keep the UIKit layer pointing the same way as the SwiftUI one.
    .onAppear { LayoutDirectionBridge.apply(layoutDirection) }
    .onChange(of: layoutDirection) { LayoutDirectionBridge.apply($0) }

// Answers arrive one tap at a time; batching keeps the app off
// the filesystem during a fast session.
private static let saveDebounceNanoseconds: UInt64 = 600_000_000

private func scheduleSave() {
    saveTask?.cancel()
    saveTask = Task { [weak self] in
        try? await Task.sleep(nanoseconds: ProgressStore.saveDebounceNanoseconds)
        guard !Task.isCancelled, let self else { return }
        self.saveNow()
    }
}

func saveNow() {
    saveTask?.cancel()
    saveTask = nil
    guard let fileURL else { return }
    let data = try ProgressStore.encoder.encode(state)
    try data.write(to: fileURL, options: [.atomic])
}

// Throws rather than returning a partial result, so a caller can
// never half-apply a bad file.
static func decode(from data: Data) throws -> ProgressBackup {
    let backup: ProgressBackup
    do {
        backup = try decoder.decode(ProgressBackup.self, from: data)
    } catch {
        throw BackupError.notABackupFile
    }

    guard backup.app == marker else { throw BackupError.notABackupFile }
    guard backup.format <= currentFormat else {
        throw BackupError.newerFormat(backup.format)
    }
    return backup
}

# Only a v* tag triggers the device-build job
git tag v1.2
git push origin v1.2

# Then: download the unsigned .ipa artifact from the run,
# sign and install it with Sideloadly using a free Apple ID.

xcodebuild build \
  -project TOEFLVocab.xcodeproj \
  -scheme TOEFLVocab \
  -sdk iphoneos \
  -configuration Release \
  CODE_SIGNING_ALLOWED=NO \
  -derivedDataPath buildDevice

APP_PATH=$(find buildDevice/Build/Products -maxdepth 2 -name "*.app" | head -n 1)
mkdir -p Payload
cp -R "$APP_PATH" Payload/
zip -qr TOEFLVocab.ipa Payload

mutating func record(correct isCorrect: Bool,
                     at date: Date = Date()) -> Bool {
    attempts += 1
    if isCorrect {
        correct += 1
        consecutiveCorrect += 1
    } else {
        incorrect += 1
        consecutiveCorrect = 0
    }
    lastAnsweredAt = date
    currentCycle.append(isCorrect)

    guard currentCycle.count >= Self.cycleLength else { return false }
    // ... bank the cycle, then reset it
}

fun record(correct: Boolean,
           at: Instant = Instant.now()): RecordResult {
    val nextCycle = currentCycle + correct
    val base = copy(
        attempts = attempts + 1,
        correct = if (correct) this.correct + 1 else this.correct,
        incorrect = if (correct) this.incorrect else this.incorrect + 1,
        consecutiveCorrect = if (correct) consecutiveCorrect + 1 else 0,
        lastAnsweredAt = at,
        currentCycle = nextCycle,
    )

    if (nextCycle.size < CYCLE_LENGTH) return RecordResult(base, false)
    // ... bank the cycle into lastCycle, then clear it
}