솔직한 업로드

    static let jsonPolicy = HTTPSessionPolicy(requestTimeout: 15, resourceTimeout: 30, byteBudget: 8 << 20)
    static let mediaPolicy = HTTPSessionPolicy(requestTimeout: 60, resourceTimeout: 180, byteBudget: 32 << 20)
    /// One file of a capture (cwkSiblingKit todo #545). The resource ceiling
    /// never decides a moving upload: a 4 MB camera original at 20 KB/s is
    /// 200 s, past the 180 s that used to cut it and send it again from the
    /// start; 1800 s holds a 12 MB original at 7 KB/s. The idle limit is
    /// `uploadIdle`, per request.
    static let uploadPolicy = HTTPSessionPolicy(requestTimeout: 120, resourceTimeout: 1800, byteBudget: 1 << 20)

    /// Seconds without a byte counted before a file's request is a dead link.
    /// The body can go into the send buffer at once, and URLSession counts
    /// nothing while the buffer drains: on the throttled bench at 20 KB/s the
    /// 1.65 MB copy was handed over in a second, then cut by the 60 s idle limit
    /// every pass and sent again, and never landed. So the limit is the whole
    /// body's time at 15 KB/s, never under the policy's 120 s.
    static func uploadIdle(bytes: Int) -> TimeInterval {
        max(uploadPolicy.requestTimeout, Double(bytes) / 15_000)
    }
    /// The live lane waits for Pippa's one short call (measured 3-6 s).
    static let livePolicy = HTTPSessionPolicy(requestTimeout: 60, resourceTimeout: 75, byteBudget: 1 << 20)
    static let streamPolicy = HTTPSessionPolicy(requestTimeout: 120, resourceTimeout: 900, byteBudget: 8 << 20)

struct MediaUpload: Equatable, Sendable {
    enum Step: String, Sendable {
        case copy, original, document

        /// Which file this is, over its line.
        var title: String {
            switch self {
            case .copy: "This photo · a smaller size first, for Pippa to read"
            case .original: "The same photo · now at full size, to keep"
            case .document: "The document"
            }
        }

        /// The request that follows the bytes (the line's finishing word).
        var finishing: String {
            switch self {
            case .copy: "Asking Pippa"
            case .original: "Keeping it at full size"
            case .document: "Reading the document"
            }
        }
    }

    var entryId: String
    var momentId: String
    var step: Step
    var status: UploadStatus
}

    func testNoUploadLineReadsAsAPhotoCount() {
        for step in [MediaUpload.Step.copy, .original] {
            XCTAssertNil(step.title.range(of: #"\d+\s+of\s+\d+"#, options: .regularExpression),
                         "\(step.title) reads as a count of photos")
        }
        XCTAssertTrue(MediaUpload.Step.original.title.contains("same photo"),
                      "the full-size pass names the photo as the one already going up")
    }