Repository Public
1// Cross-client interoperability: a TypeScript device (apps/web/src/core/engine.ts, hosted by Tests/Tools/ts-device.ts)2// and a Swift device (VaultEngine) against the same real server — same account, both directions.3// The account passkey is shared between the two "devices" by exporting / importing the software authenticator's4// credential (private key JWK, credential id, user handle, signature counter).5import CryptoKit6import Foundation7import XCTest8@testable import SharedVaultKit910final class InteropTests: ServerTestCase {11 private var ts: TSHelper { TSHelper.shared }1213 private func args(_ pairs: (String, JSONValue)...) -> JSONValue { .object(JSONObject(pairs)) }1415 /// A TypeScript-created account; returns its recovery key.16 private func tsAccount(_ dev: String, handle: String) async throws -> String {17 try await ts.call("device", args(("dev", .string(dev))))18 let r = try await ts.call("register", args(("dev", .string(dev)), ("handle", .string(handle)), ("invite", .string(try makeInvite()))))19 return try XCTUnwrap(r["recoveryKey"]?.stringValue)20 }2122 /// Enrols a Swift device on the account of TypeScript device `trusted` through pairing approved by the TypeScript device.23 private func swiftJoins(_ trusted: String) async throws -> Dev {24 let auth = SoftwarePasskeys()25 try auth.importCredentials(try await ts.call("exportAuth", args(("dev", .string(trusted)))))26 let d = device(auth: auth, platform: "Swift device")27 let s = try await d.engine.signIn()28 XCTAssertEqual(s, .pending)29 let offer = try await d.engine.startPairing()30 let req = try await ts.call("inspectPairing", args(("dev", .string(trusted)), ("code", .string(offer.code))))31 XCTAssertEqual(req["sas"]?.stringValue, offer.sas, "both clients compute the same 6-digit fingerprint")32 XCTAssertEqual(req["platform"]?.stringValue, "Swift device")33 try await ts.call("approvePairing", args(("dev", .string(trusted)), ("pairingId", try XCTUnwrap(req["pairingId"]))))34 let st = try await d.engine.checkPairing()35 XCTAssertEqual(st, .done)36 // keep the TypeScript authenticator's counter ahead of what Swift just used37 try await ts.call("importAuth", args(("dev", .string(trusted)), ("creds", auth.exportCredentials())))38 return d39 }4041 /// Enrols a TypeScript device on the account of Swift device `trusted` through pairing approved by the Swift device.42 private func tsJoins(_ dev: String, trusted: Dev) async throws {43 try await ts.call("device", args(("dev", .string(dev))))44 try await ts.call("importAuth", args(("dev", .string(dev)), ("creds", trusted.auth.exportCredentials())))45 let s = try await ts.call("signIn", args(("dev", .string(dev))))46 XCTAssertEqual(s, "pending")47 let offer = try await ts.call("startPairing", args(("dev", .string(dev))))48 let req = try await trusted.engine.inspectPairing(code: try XCTUnwrap(offer["code"]?.stringValue))49 XCTAssertEqual(req.sas, offer["sas"]?.stringValue)50 XCTAssertEqual(req.platform, "TS device")51 try await trusted.engine.approvePairing(req)52 let st = try await ts.call("checkPairing", args(("dev", .string(dev))))53 XCTAssertEqual(st, "done")54 try trusted.auth.importCredentials(try await ts.call("exportAuth", args(("dev", .string(dev)))))55 }5657 private func tsGet(_ dev: String, _ vault: String, _ id: String) async throws -> Item? {58 let r = try await ts.call("get", args(("dev", .string(dev)), ("vaultId", .string(vault)), ("id", .string(id))))59 guard let item = r["item"] else { return nil }60 return try SPV1.normalizeItem(item)61 }6263 private func tsSave(_ dev: String, _ vault: String, _ item: Item) async throws -> String {64 try unwrap(try await ts.call("save", args(("dev", .string(dev)), ("vaultId", .string(vault)), ("item", item.jsonValue))).stringValue)65 }6667 private func tsDigest(_ dev: String) async throws -> String { try unwrap(try await ts.call("digest", args(("dev", .string(dev)))).stringValue) }68 private func tsSync(_ dev: String) async throws { try await ts.call("sync", args(("dev", .string(dev)))) }69 private func tsVault(_ dev: String) async throws -> String {70 try unwrap(try await ts.call("vaults", args(("dev", .string(dev))))[0]?["vaultId"]?.stringValue)71 }7273 private func rich(_ title: String) -> Item {74 var it = login(title)75 it.custom = [CustomField(label: "PIN é", value: "12 34", kind: .secret), CustomField(label: "memo", value: "ligne\n2 \u{1F510}", kind: .multiline)]76 it.favorite = true77 it.expiresAt = "2027-01-01"78 it.rotateEveryDays = 9079 it.urls.append(ItemUrl(url: "https://bücher.example/a?b=c", match: .host))80 return it81 }8283 // (1) + (3) + (6): TS account, Swift joins by pairing approved by TS; items, digest, attachments, conflicts.84 func testAccountCreatedByTypeScriptJoinedBySwift() async throws {85 _ = try await tsAccount("x1a", handle: "interop1")86 let v = try await tsVault("x1a")87 let fromTs = try await tsSave("x1a", v, rich("Written by TS"))88 let s = try await swiftJoins("x1a")89 // Swift reads what TypeScript wrote, field for field90 let vaults = await s.engine.vaults()91 XCTAssertEqual(vaults.map(\.vaultId), [v])92 XCTAssertEqual(vaults.first?.meta.name, "Personal")93 let got = try unwrap(await s.engine.get(vaultId: v, id: fromTs)).item94 let expected = try unwrap(try await tsGet("x1a", v, fromTs))95 XCTAssertEqual(got, expected)96 XCTAssertEqual(got.custom.last?.value, "ligne\n2 \u{1F510}")97 // TypeScript reads what Swift writes98 let fromSwift = try await s.engine.saveItem(vaultId: v, item: rich("Written by Swift"))99 try await tsSync("x1a")100 let seenByTs = try unwrap(try await tsGet("x1a", v, fromSwift))101 let mine = try unwrap(await s.engine.get(vaultId: v, id: fromSwift)).item102 XCTAssertEqual(seenByTs, mine)103 var da = try await tsDigest("x1a"), ds = await s.engine.stateDigest()104 XCTAssertEqual(da, ds, "state digests are equal on both clients")105 // both list the two devices as certified106 let devs = try await s.engine.devices()107 XCTAssertEqual(devs.count, 2)108 XCTAssertTrue(devs.allSatisfy(\.verified))109 let tsDevs = try await ts.call("devices", args(("dev", "x1a")))110 XCTAssertEqual(tsDevs.arrayValue?.count, 2)111 XCTAssertEqual(tsDevs.arrayValue?.allSatisfy { $0["verified"] == true }, true)112 XCTAssertEqual(Set(tsDevs.arrayValue?.compactMap { $0["fingerprint"]?.stringValue } ?? []), Set(devs.map(\.fingerprint)))113114 // edits both ways keep the password history and stay in step115 var edit = mine116 edit.fields["password"] = "changed-by-swift"117 try await s.engine.saveItem(vaultId: v, id: fromSwift, item: edit)118 try await tsSync("x1a")119 try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(fromSwift)), ("patch", ["notes": "note by TS"])))120 try await s.engine.sync()121 let after = try unwrap(await s.engine.get(vaultId: v, id: fromSwift))122 XCTAssertEqual(after.item.notes, "note by TS")123 XCTAssertEqual(after.item.fields["password"], "changed-by-swift")124 XCTAssertEqual(after.item.passwordHistory.map(\.value), [SECRET_PW])125 XCTAssertEqual(after.rev, 3)126 let history = try await s.engine.history(vaultId: v, id: fromSwift)127 XCTAssertEqual(history.map(\.rev), [2, 1], "Swift decrypts the revisions written by both clients")128129 // (3) attachments both ways130 let payload = SPV1.random(1024 * 1024 + 4321)131 let ref = try await s.engine.upload(vaultId: v, name: "from-swift.bin", mime: "application/octet-stream", data: payload)132 var doc = SPV1.newItem(.document, title: "Swift attachment")133 doc.attachments = [ref]134 let docId = try await s.engine.saveItem(vaultId: v, item: doc)135 try await tsSync("x1a")136 let tsDoc = try unwrap(try await tsGet("x1a", v, docId))137 XCTAssertEqual(tsDoc.attachments, [ref])138 let dl = try await ts.call("download", args(("dev", "x1a"), ("ref", ref.jsonValue)))139 XCTAssertEqual(dl["size"]?.intValue, payload.count)140 XCTAssertEqual(dl["sha256"]?.stringValue, SPV1.b64u(SPV1.sha256(payload)))141 let payload2 = SPV1.random(1024 * 1024 + 99)142 let tsRef = try await ts.call("upload", args(("dev", "x1a"), ("vaultId", .string(v)), ("name", "from-ts.bin"), ("mime", "application/octet-stream"), ("data", .string(payload2.base64EncodedString()))))143 var tsDocItem = SPV1.newItem(.document, title: "TS attachment").jsonValue.objectValue ?? JSONObject()144 tsDocItem["attachments"] = [tsRef]145 let tsDocId = try unwrap(try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("item", .object(tsDocItem)))).stringValue)146 try await s.engine.sync()147 let swiftRef = try unwrap(await s.engine.get(vaultId: v, id: tsDocId)?.item.attachments.first)148 XCTAssertEqual(swiftRef.chunks, 2)149 let downloaded = try await s.engine.download(swiftRef)150 XCTAssertEqual(downloaded, payload2)151152 // (6) conflict: a TypeScript edit against an offline Swift edit → same final state on both153 s.api.offline = true154 var offlineEdit = try unwrap(await s.engine.get(vaultId: v, id: fromTs)).item155 offlineEdit.notes = "edited offline in Swift"156 try await s.engine.saveItem(vaultId: v, id: fromTs, item: offlineEdit)157 try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(fromTs)), ("patch", ["notes": "edited online in TS"])))158 s.api.offline = false159 try await s.engine.sync()160 try await tsSync("x1a")161 let swiftList = await s.engine.list()162 let winner = try unwrap(await s.engine.get(vaultId: v, id: fromTs))163 XCTAssertEqual(winner.item.notes, "edited online in TS")164 let copy = try XCTUnwrap(swiftList.first { $0.item.conflictOf == fromTs })165 XCTAssertEqual(copy.item.notes, "edited offline in Swift")166 XCTAssertEqual(copy.item.title, "Written by TS (conflict copy)")167 let tsWinner = try unwrap(try await tsGet("x1a", v, fromTs))168 XCTAssertEqual(tsWinner, winner.item)169 let tsCopy = try unwrap(try await tsGet("x1a", v, copy.recordId))170 XCTAssertEqual(tsCopy, copy.item)171 da = try await tsDigest("x1a"); ds = await s.engine.stateDigest()172 XCTAssertEqual(da, ds)173174 // the mirror image: TypeScript offline, Swift online — TypeScript makes the conflict copy, Swift reads it175 try await ts.call("offline", args(("dev", "x1a"), ("value", true)))176 try await ts.call("save", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(fromSwift)), ("patch", ["notes": "edited offline in TS"])))177 var online = try unwrap(await s.engine.get(vaultId: v, id: fromSwift)).item178 online.notes = "edited online in Swift"179 try await s.engine.saveItem(vaultId: v, id: fromSwift, item: online)180 try await ts.call("offline", args(("dev", "x1a"), ("value", false)))181 try await tsSync("x1a")182 try await s.engine.sync()183 let w2 = try unwrap(await s.engine.get(vaultId: v, id: fromSwift))184 XCTAssertEqual(w2.item.notes, "edited online in Swift")185 let copy2 = try unwrap(await s.engine.list().first { $0.item.conflictOf == fromSwift })186 XCTAssertEqual(copy2.item.notes, "edited offline in TS")187 let tsW2 = try unwrap(try await tsGet("x1a", v, fromSwift))188 XCTAssertEqual(tsW2, w2.item)189 da = try await tsDigest("x1a"); ds = await s.engine.stateDigest()190 XCTAssertEqual(da, ds)191 let h = try await ts.call("health", args(("dev", "x1a")))192 XCTAssertEqual(h["pending"], 0)193 XCTAssertEqual(h["warnings"], [])194 let warnings = await s.engine.syncHealth().warnings195 XCTAssertEqual(warnings, [])196197 // deletion by one client is a tombstone the other authenticates198 try await s.engine.deleteItem(vaultId: v, id: copy.recordId)199 try await tsSync("x1a")200 let deleted = try await tsGet("x1a", v, copy.recordId)201 XCTAssertNil(deleted)202 try await ts.call("deleteItem", args(("dev", "x1a"), ("vaultId", .string(v)), ("id", .string(copy2.recordId))))203 try await s.engine.sync()204 let deleted2 = await s.engine.get(vaultId: v, id: copy2.recordId)205 XCTAssertNil(deleted2)206 da = try await tsDigest("x1a"); ds = await s.engine.stateDigest()207 XCTAssertEqual(da, ds)208 }209210 // (2): Swift account, a TypeScript device joins by pairing approved by Swift; then a key rotation by each side.211 func testAccountCreatedBySwiftJoinedByTypeScript() async throws {212 let (s, recoveryKey) = try await newAccount("interop2", platform: "Swift device")213 let v = try await personal(s)214 let fromSwift = try await s.engine.saveItem(vaultId: v, item: rich("Swift first"))215 try await tsJoins("x2b", trusted: s)216 let tsVaults = try await ts.call("vaults", args(("dev", "x2b")))217 XCTAssertEqual(tsVaults[0]?["name"], "Personal")218 XCTAssertEqual(tsVaults[0]?["vaultId"], .string(v))219 let seen = try unwrap(try await tsGet("x2b", v, fromSwift))220 let mine = try unwrap(await s.engine.get(vaultId: v, id: fromSwift)).item221 XCTAssertEqual(seen, mine)222 let fromTs = try await tsSave("x2b", v, rich("TS second"))223 try await s.engine.sync()224 let got = try unwrap(await s.engine.get(vaultId: v, id: fromTs)).item225 let expected = try unwrap(try await tsGet("x2b", v, fromTs))226 XCTAssertEqual(got, expected)227 var dt = try await tsDigest("x2b"), ds = await s.engine.stateDigest()228 XCTAssertEqual(dt, ds)229 // the TypeScript device unlocks offline from the envelope Swift wrapped for it, and signs in with its device proof230 try await ts.call("lock", args(("dev", "x2b")))231 try await ts.call("unlockOffline", args(("dev", "x2b")))232 try await ts.call("lock", args(("dev", "x2b")))233 let again = try await ts.call("signIn", args(("dev", "x2b")))234 XCTAssertEqual(again, "unlocked")235 try s.auth.importCredentials(try await ts.call("exportAuth", args(("dev", "x2b"))))236237 // vault key rotation by Swift: TypeScript follows to epoch 2 and reads the re-encrypted records238 try await s.engine.rotateVaultKey(vaultId: v, remove: [])239 try await tsSync("x2b")240 let tsAfter = try await ts.call("vaults", args(("dev", "x2b")))241 XCTAssertEqual(tsAfter[0]?["epoch"], 2)242 XCTAssertEqual(try psql("select distinct envelope->>'kid' from records where vault_id = '\(v)'"), "2")243 let reread = try await tsGet("x2b", v, fromSwift)244 XCTAssertEqual(reread, mine)245 // …and by TypeScript: Swift follows to epoch 3246 try await ts.call("rotateVaultKey", args(("dev", "x2b"), ("vaultId", .string(v))))247 try await s.engine.sync()248 let epoch = await s.engine.vaults().first?.epoch249 XCTAssertEqual(epoch, 3)250 let reread2 = await s.engine.get(vaultId: v, id: fromTs)?.item251 XCTAssertEqual(reread2, expected)252 dt = try await tsDigest("x2b"); ds = await s.engine.stateDigest()253 XCTAssertEqual(dt, ds)254255 // backup made by Swift, opened by the TypeScript engine of the same account (and the other way round)256 let backup = try await s.engine.exportBackup()257 let restored = try await ts.call("restoreBackup", args(("dev", "x2b"), ("text", .string(backup))))258 XCTAssertEqual(restored, 2)259 try await s.engine.sync()260 let n = await s.engine.vaults().count261 XCTAssertEqual(n, 2)262 let tsBackup = try unwrap(try await ts.call("exportBackup", args(("dev", "x2b"))).stringValue)263 let opened = try SPV1.openBackup(try SPV1.parseBackup(tsBackup), secret: .recoveryKey(try SPV1.decodeRecoveryKey(recoveryKey)))264 XCTAssertEqual(opened.payload.vaults.count, 2)265266 // account rekey by Swift: the TypeScript device is signed out, signs in again and reads with the new keys267 let rk2 = try await s.engine.rekeyAccount()268 try await ts.call("importAuth", args(("dev", "x2b"), ("creds", s.auth.exportCredentials())))269 try await ts.call("lock", args(("dev", "x2b")))270 let relogin = try await ts.call("signIn", args(("dev", "x2b")))271 XCTAssertEqual(relogin, "unlocked")272 try s.auth.importCredentials(try await ts.call("exportAuth", args(("dev", "x2b"))))273 try await tsSync("x2b")274 let afterRekey = try await tsGet("x2b", v, fromSwift)275 XCTAssertEqual(afterRekey, mine)276 try await s.engine.sync()277 dt = try await tsDigest("x2b"); ds = await s.engine.stateDigest()278 XCTAssertEqual(dt, ds)279 // (5, mirrored) recovery of a Swift-created account on a TypeScript device with the rotated recovery key280 try await ts.call("device", args(("dev", "x2c")))281 try await ts.call("recover", args(("dev", "x2c"), ("handle", "interop2"), ("recoveryKey", .string(rk2))))282 let recovered = try await tsGet("x2c", v, fromSwift)283 XCTAssertEqual(recovered, mine)284 }285286 // (4): relay shares between a TypeScript account and a Swift account, to an account and by link, both directions;287 // plus a shared vault owned by the TypeScript account.288 func testRelayAndSharedVaultBetweenTypeScriptAndSwiftAccounts() async throws {289 _ = try await tsAccount("x3a", handle: "interop3ts")290 let (s, _) = try await newAccount("interop3swift")291 // TS → Swift account292 let recipient = try await ts.call("lookup", args(("dev", "x3a"), ("handle", "interop3swift")))293 let me = try await s.engine.lookupAccount(handle: "interop3swift")294 XCTAssertEqual(recipient["fingerprint"]?.stringValue, me.fingerprint, "both clients compute the same account fingerprint")295 let sid = try unwrap(try await ts.call("shareAccount", args(("dev", "x3a"), ("item", rich("Shared by TS").jsonValue), ("recipient", recipient))).stringValue)296 let received = try await s.engine.shares()297 XCTAssertEqual(received.received.map(\.id), [sid])298 XCTAssertEqual(received.received.first?.senderHandle, "interop3ts")299 let opened = try await s.engine.openShare(id: sid)300 XCTAssertEqual(opened.from, "interop3ts")301 XCTAssertEqual(opened.item.title, "Shared by TS")302 XCTAssertEqual(opened.item.fields["password"], SECRET_PW)303 XCTAssertEqual(opened.item.custom.first?.value, "12 34")304 // TS → link, opened by Swift without an account305 let url = try unwrap(try await ts.call("shareLink", args(("dev", "x3a"), ("item", rich("Link by TS").jsonValue))).stringValue)306 let viaLink = try await VaultEngine.openLinkShare(url: url, transport: device().api)307 XCTAssertEqual(viaLink.title, "Link by TS")308 XCTAssertEqual(viaLink.fields["totp"], "JBSWY3DPEHPK3PXP")309 // Swift → TS account310 let tsAccountInfo = try await s.engine.lookupAccount(handle: "interop3ts")311 let sid2 = try await s.engine.shareWithAccount(item: rich("Shared by Swift"), recipient: tsAccountInfo, expiresInSec: 3600)312 let tsOpened = try await ts.call("openShare", args(("dev", "x3a"), ("id", .string(sid2))))313 XCTAssertEqual(tsOpened["from"], "interop3swift")314 XCTAssertEqual(try SPV1.normalizeItem(try XCTUnwrap(tsOpened["item"])).title, "Shared by Swift")315 XCTAssertEqual(tsOpened["item"]?["fields"]?["password"]?.stringValue, SECRET_PW)316 // Swift → link, opened by TypeScript317 let url2 = try await s.engine.shareByLink(item: rich("Link by Swift"), origin: "https://vault.example", expiresInSec: 3600)318 let tsLink = try await ts.call("openLink", args(("url", .string(url2))))319 XCTAssertEqual(tsLink["title"], "Link by Swift")320321 // shared vault owned by the TypeScript account: Swift is a member (grants issued by TS, owner key pinned by Swift)322 let shared = try unwrap(try await ts.call("createVault", args(("dev", "x3a"), ("name", "Équipe"))).stringValue)323 let inShared = try await tsSave("x3a", shared, rich("In the shared vault"))324 try await ts.call("addMember", args(("dev", "x3a"), ("vaultId", .string(shared)), ("member", recipient), ("role", "editor")))325 try await s.engine.sync()326 let sv = try unwrap(await s.engine.vaults().first { $0.vaultId == shared })327 XCTAssertEqual(sv.meta.name, "Équipe")328 XCTAssertEqual(sv.role, .editor)329 XCTAssertEqual(sv.members.count, 2)330 let item = await s.engine.get(vaultId: shared, id: inShared)331 XCTAssertEqual(item?.item.title, "In the shared vault")332 let added = try await s.engine.saveItem(vaultId: shared, item: rich("Added by the Swift member"))333 try await tsSync("x3a")334 let tsSees = try await tsGet("x3a", shared, added)335 XCTAssertEqual(tsSees?.title, "Added by the Swift member")336 // …and one owned by the Swift account with the TypeScript account as reader, then removed (rotation)337 let mine = try await s.engine.createVault(meta: VaultMeta(name: "Swift shared", kind: .shared))338 let secret = try await s.engine.saveItem(vaultId: mine, item: rich("Owned by Swift"))339 try await s.engine.addMember(vaultId: mine, member: tsAccountInfo, role: .reader)340 try await tsSync("x3a")341 let tsReads = try await tsGet("x3a", mine, secret)342 XCTAssertEqual(tsReads?.title, "Owned by Swift")343 try await s.engine.rotateVaultKey(vaultId: mine, remove: [tsAccountInfo.accountId])344 try await tsSync("x3a")345 let tsVaults = try await ts.call("vaults", args(("dev", "x3a")))346 XCTAssertFalse((tsVaults.arrayValue ?? []).contains { $0["vaultId"]?.stringValue == mine })347 }348349 // (5): recovery of a TypeScript-created account on a fresh Swift device with the recovery key.350 func testRecoveryOfTypeScriptAccountOnSwiftDevice() async throws {351 let recoveryKey = try await tsAccount("x4a", handle: "interop4")352 let v = try await tsVault("x4a")353 let id = try await tsSave("x4a", v, rich("Recovered on Swift"))354 let fresh = device(platform: "Swift replacement")355 try await fresh.engine.recover(handle: "interop4", recoveryKey: recoveryKey)356 let got = try unwrap(await fresh.engine.get(vaultId: v, id: id)).item357 let expected = try unwrap(try await tsGet("x4a", v, id))358 XCTAssertEqual(got, expected)359 let dt = try await tsDigest("x4a"), ds = await fresh.engine.stateDigest()360 XCTAssertEqual(dt, ds)361 // the recovered Swift device is a full device: it writes, adds its own passkey, and rotates the recovery key362 let written = try await fresh.engine.saveItem(vaultId: v, item: rich("After recovery"))363 try await tsSync("x4a")364 let seen = try await tsGet("x4a", v, written)365 XCTAssertEqual(seen?.title, "After recovery")366 try await fresh.engine.addPasskey(label: "swift")367 await fresh.engine.lock()368 let s = try await fresh.engine.signIn()369 XCTAssertEqual(s, .unlocked)370 let rk2 = try await fresh.engine.rotateRecoveryKey()371 try await ts.call("device", args(("dev", "x4b")))372 do {373 try await ts.call("recover", args(("dev", "x4b"), ("handle", "interop4"), ("recoveryKey", .string(recoveryKey))))374 XCTFail("the old recovery key must stop working")375 } catch let e as TSError { XCTAssertEqual(e.status, 401) }376 try await ts.call("recover", args(("dev", "x4b"), ("handle", "interop4"), ("recoveryKey", .string(rk2))))377 let again = try await tsGet("x4b", v, written)378 XCTAssertEqual(again?.title, "After recovery")379 let kinds = try await fresh.engine.audit().map(\.kind)380 XCTAssertTrue(kinds.contains("recovery.started") && kinds.contains("recovery.rotated") && kinds.contains("account.created"))381 let events = try await fresh.engine.audit()382 let ok = await fresh.engine.verifyAuditPage(events)383 XCTAssertTrue(ok, "Swift verifies the audit chain of events produced for both clients")384 }385}386