거짓말 못 하는 오프라인 사본

    init(root: URL, endpoint: EngineEndpoint) {
        directory = root.appendingPathComponent(OfflineKey.filename((try? endpoint.baseURL().absoluteString) ?? "invalid"), isDirectory: true)
    }

    struct Ticket { let generation: Int; let id: UUID }

    func begin(_ path: String) -> Ticket {
        lock.withLock {
            let id = UUID()
            reads[path] = id
            return Ticket(generation: generation, id: id)
        }
    }

    func isCurrent(_ ticket: Ticket, path: String) -> Bool {
        lock.withLock { !retired && ticket.generation == generation && reads[path] == ticket.id }
    }

    func didMutate() { lock.withLock { generation += 1 } }
    func retire() { lock.withLock { retired = true; generation += 1 } }
    var hasWriteFailure: Bool { lock.withLock { !failedPaths.isEmpty } }

    private func get<T: Decodable>(_ path: String) async throws -> T {
        let mirrored = path == "/api/encounters" || path == "/api/tree"
            || path.hasPrefix("/api/encounters/") || path.hasPrefix("/api/classes/") || path.hasPrefix("/api/threads/")
        let ticket = mirrored ? shelf?.begin(path) : nil
        let reply = try await transport(try request("GET", path))
        let value: T = try decode(reply)
        try Task.checkCancellation()
        if let ticket, let shelf {
            guard shelf.isCurrent(ticket, path: path) else { throw CancellationError() }
            shelf.write(reply.data, path: path, ticket: ticket)
        }
        return value
    }

    private func send<T: Decodable>(_ method: String, _ path: String, json: [String: String]? = nil) async throws -> T {
        var request = try request(method, path)
        if let json {
            request.setValue("application/json", forHTTPHeaderField: "Content-Type")
            request.httpBody = try JSONSerialization.data(withJSONObject: json)
        }
        let value: T = try decode(try await transport(request))
        shelf?.didMutate()
        if let detail = value as? EncounterDetail { shelf?.remember(detail) }
        if let detail = value as? ClassDetail { shelf?.save(detail, path: "/api/classes/\(detail.class.id)") }
        if let reply = value as? AskReply { shelf?.save(reply.thread, path: "/api/threads/\(Self.escape(reply.thread.key))") }
        return value
    }

    func testOldReadsCannotReplaceACompletedMutation() async throws {
        let app = model(online().transport)
        let shelf = try XCTUnwrap(app.client.shelf)
        let before = shelf.begin("/api/encounters")
        shelf.didMutate()
        let detail = try JSONDecoder().decode(EncounterDetail.self, from: Data(Self.detail.utf8))
        XCTAssertTrue(shelf.remember(detail))
        XCTAssertFalse(shelf.write(Data("{\"encounters\":[]}".utf8), path: "/api/encounters", ticket: before))
        XCTAssertEqual(model(online().transport).plates.count, 1)
    }