아웃박스: 담은 건 절대 안 잃어버려

import Foundation

enum OutboxState: String, Codable, Sendable {
    case queued = "QUEUED"
    case syncing = "SYNCING"
    case synced = "SYNCED"
    case needsAttention = "FAILED_NEEDS_ATTENTION"
}

struct OutboxEntry: Codable, Sendable, Equatable {
    let id: String               // minted on the device; the engine answers a replay of it idempotently
    var state: OutboxState
    var pendingMedia: [String]   // still to upload, consumed as each upload lands
    let ownedMedia: [String]     // what to delete on every exit path, never consumed
    var lastError: String?
}

enum SendFailure: Error, Equatable {
    case transient(String)
    case permanent(String)
}

/// A wrong session or a busy engine is a wait. Another 4xx refuses THIS payload.
func classify(status: Int) -> SendFailure? {
    switch status {
    case 200..<300: nil
    case 401, 403, 408, 425, 429: .transient("HTTP \(status)")
    case 400..<500: .permanent("HTTP \(status)")
    default: .transient("HTTP \(status)")
    }
}

struct Outbox {
    private(set) var entries: [OutboxEntry] = []

    /// Idempotent on id: a payload offered twice stays one entry.
    mutating func enqueue(_ entry: OutboxEntry) {
        guard !entries.contains(where: { $0.id == entry.id }) else { return }
        entries.append(entry)
    }

    /// At launch. A send killed mid-flight goes back in line; the engine dedupes the replay.
    mutating func recoverInterruptedSends() {
        for index in entries.indices where entries[index].state == .syncing {
            entries[index].state = .queued
        }
    }

    /// One pass in order. Permanent: park that entry and continue. Transient: requeue and stop.
    mutating func drain(send: @Sendable (OutboxEntry) async -> Int) async -> (synced: Int, haltedBecause: String?) {
        var synced = 0
        for index in entries.indices where entries[index].state == .queued {
            entries[index].state = .syncing
            switch classify(status: await send(entries[index])) {
            case nil:
                entries[index].state = .synced
                synced += 1
            case .permanent(let reason)?:
                entries[index].state = .needsAttention
                entries[index].lastError = reason
            case .transient(let reason)?:
                entries[index].state = .queued
                return (synced, reason)
            }
        }
        return (synced, nil)
    }
}

entries after double offer: 4
states after recovery: ["QUEUED", "QUEUED", "QUEUED", "QUEUED"]
outcome: (synced: 1, haltedBecause: Optional("HTTP 503"))
states after drain: ["01A=SYNCED", "01B=FAILED_NEEDS_ATTENTION", "01C=QUEUED", "01D=QUEUED"]