How do you make a shared payload that an older widget can still decode after the app adds a new case?

Predict first

What does each decoder do with an unknown "wallet" case and an extra key?

import Foundation

enum Kind: Codable, Equatable {
    case card, loan, unknown(String)
    init(from decoder: Decoder) throws {
        let s = try decoder.singleValueContainer().decode(String.self)
        switch s { case "card": self = .card; case "loan": self = .loan; default: self = .unknown(s) }
    }
    func encode(to encoder: Encoder) throws {
        var c = encoder.singleValueContainer()
        switch self { case .card: try c.encode("card"); case .loan: try c.encode("loan"); case .unknown(let s): try c.encode(s) }
    }
}
struct Account: Codable { var kind: Kind; var balance: Int; var note: String? }

enum StrictKind: String, Codable { case card, loan }
struct StrictAccount: Codable { var kind: StrictKind; var balance: Int }

let newer = Data(#"{"kind":"wallet","balance":5,"extraField":1}"#.utf8)
print("strict:", (try? JSONDecoder().decode(StrictAccount.self, from: newer)) == nil ? "failed" : "decoded")
let a = try JSONDecoder().decode(Account.self, from: newer)
print("tolerant:", a.kind, a.balance, a.note as Any)

• strict fails; tolerant decodes as unknown("wallet") with note nil
• Both decode
• Both fail