crossmate

FriendController.swift (28239B)

---

 import CloudKit
 import CoreData
 import Foundation
 
 /// Sibling of `ShareController`, but for *friend* zones rather than game
 /// zones. A friendship is a durable, pairwise channel: one custom zone
 /// (`friend-<pairKey>`) carrying a zone-wide `CKShare` with the other user
 /// added as a `.readWrite` participant. The zone is created in the elected
 /// owner's private database and accepted into the other user's shared
 /// database; thereafter either side can write `.invite` `Ping`s into it.
 ///
 /// Bootstrap rides the *game* zone the two users already share: the owner
 /// enqueues a `.friend` `Ping` whose `payload` carries the friend-zone share
 /// URL. The other device applies it (`applyFriendPing`) and accepts the
 /// share without any out-of-band link.
 @MainActor
 final class FriendController {
     let container: CKContainer
     private let persistence: PersistenceController
     private let syncEngine: SyncEngine
     private let syncMonitor: SyncMonitor?
     private let eventLog: EventLog?
     private let fetchAccountDecisionRecord: (CKRecord.ID) async throws -> CKRecord
 
     init(
         container: CKContainer,
         persistence: PersistenceController,
         syncEngine: SyncEngine,
         syncMonitor: SyncMonitor? = nil,
         eventLog: EventLog? = nil,
         fetchAccountDecisionRecord: ((CKRecord.ID) async throws -> CKRecord)? = nil
     ) {
         self.container = container
         self.persistence = persistence
         self.syncEngine = syncEngine
         self.syncMonitor = syncMonitor
         self.eventLog = eventLog
         self.fetchAccountDecisionRecord = fetchAccountDecisionRecord
             ?? { try await container.privateCloudDatabase.record(for: $0) }
     }
 
     enum FriendError: Error {
         case invalidShareRecord
         case missingShareURL
         case participantNotFound
         case missingShareURLInPayload
         case friendNotFound
         case friendBlocked
         case payloadEncodingFailed
     }
 
     // MARK: - Owner side
 
     /// Creates the friendship if this device is the elected owner and no
     /// friendship for the pair exists yet. No-ops for the non-owner (it
     /// waits for the `.friend` Ping) and for an already-established pair.
     /// `viaGameID` is the shared game whose zone carries the bootstrap Ping.
     func establishIfOwner(
         localAuthorID: String,
         remoteAuthorID: String,
         localDisplayName: String?,
         viaGameID: UUID
     ) async {
         guard !remoteAuthorID.isEmpty,
               localAuthorID != remoteAuthorID,
               FriendZone.isOwner(localAuthorID: localAuthorID, remoteAuthorID: remoteAuthorID)
         else { return }
 
         let pairKey = FriendZone.pairKey(localAuthorID, remoteAuthorID)
         if friendExists(pairKey: pairKey) { return }
 
         syncMonitor?.recordStart("establish friendship")
         do {
             let zoneName = FriendZone.zoneName(pairKey: pairKey)
             let zoneID = CKRecordZone.ID(zoneName: zoneName, ownerName: CKCurrentUserDefaultName)
 
             // Every field of the local friendship is deterministic or already
             // in hand, so any owner-side device can record it without reading
             // anything back from the share.
             let recordLocalFriendship = {
                 self.persistFriend(
                     authorID: remoteAuthorID,
                     pairKey: pairKey,
                     zoneName: zoneName,
                     zoneOwnerName: CKCurrentUserDefaultName,
                     databaseScope: 0
                 )
             }
 
             try await createZone(zoneID)
 
             // A sibling device on this same iCloud account may have already
             // created the zone-wide share. `FriendEntity` is local-only, so
             // the `friendExists` check above can't see its work and we still
             // reach here. If the share exists we adopt the friendship locally
             // *without* re-creating the share or re-enqueuing the `.friend`
             // Ping — the sibling already delivered it to the friend.
             if try await existingZoneWideShare(zoneID: zoneID) != nil {
                 recordLocalFriendship()
                 await seedOwnNameDecision(
                     localAuthorID: localAuthorID,
                     localDisplayName: localDisplayName,
                     zoneID: zoneID,
                     scope: 0
                 )
                 syncMonitor?.recordSuccess("establish friendship")
                 return
             }
 
             let share: CKShare
             do {
                 share = try await saveZoneWideShare(
                     zoneID: zoneID,
                     addingParticipant: remoteAuthorID
                 )
             } catch let error as CKError where error.code == .serverRecordChanged {
                 // Lost the create race to a sibling between the check above
                 // and this save. The share now exists; adopt it as above.
                 recordLocalFriendship()
                 await seedOwnNameDecision(
                     localAuthorID: localAuthorID,
                     localDisplayName: localDisplayName,
                     zoneID: zoneID,
                     scope: 0
                 )
                 syncMonitor?.recordSuccess("establish friendship")
                 return
             }
             guard let url = share.url else { throw FriendError.missingShareURL }
 
             recordLocalFriendship()
             await seedOwnNameDecision(
                 localAuthorID: localAuthorID,
                 localDisplayName: localDisplayName,
                 zoneID: zoneID,
                 scope: 0
             )
 
             let payload = FriendZone.BootstrapPayload(
                 friendShareURL: url.absoluteString,
                 pairKey: pairKey,
                 ownerAuthorID: localAuthorID
             )
             await syncEngine.enqueuePing(
                 kind: .friend,
                 gameID: viaGameID,
                 authorID: localAuthorID,
                 playerName: localDisplayName ?? "",
                 payload: payload.encodedString()
             )
             syncMonitor?.recordSuccess("establish friendship")
         } catch {
             syncMonitor?.recordError("establish friendship", error)
         }
     }
 
     /// Writes the local user's current name into a just-recorded friend zone
     /// as a `name` Decision, at the current (un-bumped) generation: a seed is
     /// "the name as of this friendship", never a rename, so it must lose to
     /// any real rename racing it. This is how a friend made *after* the last
     /// rename learns the name — the rename fan-out only reaches zones that
     /// existed at the time.
     private func seedOwnNameDecision(
         localAuthorID: String,
         localDisplayName: String?,
         zoneID: CKRecordZone.ID,
         scope: Int16
     ) async {
         let name = (localDisplayName ?? "")
             .trimmingCharacters(in: .whitespacesAndNewlines)
         guard !name.isEmpty else { return }
         await syncEngine.enqueueNameDecision(
             authorID: localAuthorID,
             name: name,
             version: NameVersionStore.current(authorID: localAuthorID),
             zoneID: zoneID,
             scope: scope
         )
     }
 
     // MARK: - Participant side
 
     /// Handles an inbound `.friend` Ping: accepts the friend-zone share and
     /// records the friendship. Idempotent — a duplicate Ping for an
     /// already-established pair is dropped. `localAuthorID`/`localDisplayName`
     /// let the acceptor seed its own name Decision into the just-joined zone
     /// so the owner learns this side's name without waiting for a rename.
     func applyFriendPing(
         _ ping: Ping,
         localAuthorID: String?,
         localDisplayName: String?
     ) async {
         guard ping.kind == .friend,
               let payload = FriendZone.BootstrapPayload.decode(ping.payload)
         else { return }
         guard FriendZone.canAcceptBootstrap(payload, localAuthorID: localAuthorID) else { return }
         if friendExists(pairKey: payload.pairKey) { return }
         guard let url = URL(string: payload.friendShareURL) else { return }
 
         syncMonitor?.recordStart("accept friendship")
         do {
             let metadata = try await fetchShareMetadata(url: url)
             try await accept(metadata)
             let zoneID = metadata.share.recordID.zoneID
             persistFriend(
                 authorID: payload.ownerAuthorID,
                 pairKey: payload.pairKey,
                 zoneName: zoneID.zoneName,
                 zoneOwnerName: zoneID.ownerName,
                 databaseScope: 1
             )
             if let localAuthorID, !localAuthorID.isEmpty {
                 await seedOwnNameDecision(
                     localAuthorID: localAuthorID,
                     localDisplayName: localDisplayName,
                     zoneID: zoneID,
                     scope: 1
                 )
             }
             syncMonitor?.recordSuccess("accept friendship")
             // `applyFriendPing` runs inside the `onPings` CKSyncEngine
             // delegate callback. Awaiting a call back into CKSyncEngine from
             // there trips its serialization guard and crashes
             // (CKSyncEngine.swift:293: "Cannot await a call into CKSyncEngine
             // from within a delegate callback"). Detach the post-accept
             // refresh so the delegate callback returns first; it only needs
             // to land eventually.
             // Detached (not a plain `Task {}`): a `Task {}` here inherits this
             // @MainActor context and can run `fetchChanges()` at one of the
             // delegate callback's own suspension points — before `handleEvent`
             // returns — so CKSyncEngine's guard still trips. A detached task
             // runs off this actor, after the callback unwinds. (`Task {}` was
             // the original, insufficient fix; the trap recurred in 2026.310.)
             Task.detached { [syncEngine, syncMonitor] in
                 await syncMonitor?.run("friendship accept fetch") {
                     try await syncEngine.fetchChanges()
                 }
             }
         } catch {
             syncMonitor?.recordError("accept friendship", error)
         }
     }
 
     // MARK: - Re-invite
 
     /// Writes an `.invite` Ping carrying the game's share URL into the friend
     /// zone. The friend must already be added as a participant on the game's
     /// `CKShare` (the caller does that via `ShareController` and passes the
     /// resulting URL in). No-ops for an unknown or blocked friend. The optional
     /// `gridSilhouette` is a `GridSilhouette`-encoded segment that lets the
     /// recipient's "Invited" row preview the puzzle's shape.
     func sendInvite(
         toFriendAuthorID friendAuthorID: String,
         gameID: UUID,
         gameTitle: String,
         inviterAuthorID: String,
         inviterName: String,
         gameShareURL: URL,
         gridSilhouette: String? = nil,
         puzzleSource: String? = nil
     ) async throws {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
         req.predicate = NSPredicate(format: "authorID == %@", friendAuthorID)
         req.fetchLimit = 1
         guard let friend = try ctx.fetch(req).first else {
             throw FriendError.friendNotFound
         }
         guard !friend.isBlocked else { throw FriendError.friendBlocked }
         guard let zoneName = friend.friendZoneName,
               let ownerName = friend.friendZoneOwnerName
         else { throw FriendError.friendNotFound }
 
         let payload = FriendZone.InvitePayload(
             gameShareURL: gameShareURL.absoluteString,
             gridSilhouette: gridSilhouette,
             puzzleSource: puzzleSource
         )
         guard let encoded = payload.encodedString() else {
             throw FriendError.payloadEncodingFailed
         }
 
         await syncEngine.enqueueFriendZonePing(
             kind: .invite,
             gameID: gameID,
             gameTitle: gameTitle,
             authorID: inviterAuthorID,
             playerName: inviterName,
             addressee: friendAuthorID,
             friendZoneID: CKRecordZone.ID(zoneName: zoneName, ownerName: ownerName),
             friendZoneScope: friend.databaseScope,
             payload: encoded
         )
     }
 
     /// Writes a `.decline` Ping into the friend zone telling the inviter we
     /// turned down their game invite, so their device frees our seat on the
     /// game's `CKShare` and surfaces a banner. Mirrors `sendInvite` reversed:
     /// `declinerAuthorID` is us (the sender), `inviterAuthorID` the addressee.
     /// Carries no payload — `(gameID, declinerAuthorID)` fully identify the seat
     /// to free. No-ops for an unknown or blocked friend.
     func sendDecline(
         toInviterAuthorID inviterAuthorID: String,
         gameID: UUID,
         gameTitle: String,
         declinerAuthorID: String,
         declinerName: String
     ) async throws {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
         req.predicate = NSPredicate(format: "authorID == %@", inviterAuthorID)
         req.fetchLimit = 1
         guard let friend = try ctx.fetch(req).first else {
             throw FriendError.friendNotFound
         }
         guard !friend.isBlocked else { throw FriendError.friendBlocked }
         guard let zoneName = friend.friendZoneName,
               let ownerName = friend.friendZoneOwnerName
         else { throw FriendError.friendNotFound }
 
         await syncEngine.enqueueFriendZonePing(
             kind: .decline,
             gameID: gameID,
             gameTitle: gameTitle,
             authorID: declinerAuthorID,
             playerName: declinerName,
             addressee: inviterAuthorID,
             friendZoneID: CKRecordZone.ID(zoneName: zoneName, ownerName: ownerName),
             friendZoneScope: friend.databaseScope
         )
     }
 
     /// Consume-deletes a directed Ping from the pairwise friend zone — an
     /// `.invite` once it has been accepted or found stale, or a `.decline` once
     /// the addressed inviter has freed the seat. Removing the source record
     /// stops it re-creating on the recipient's devices and withdraws any banner
     /// a sibling showed. `friendAuthorID` is the *other* party on the zone (the
     /// inviter for an invite we consume, the decliner for a decline we consume).
     func deleteFriendZonePing(fromFriendAuthorID friendAuthorID: String, recordName: String) async {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
         req.predicate = NSPredicate(format: "authorID == %@", friendAuthorID)
         req.fetchLimit = 1
         guard let friend = try? ctx.fetch(req).first,
               let zoneName = friend.friendZoneName,
               let ownerName = friend.friendZoneOwnerName
         else { return }
 
         await syncEngine.deletePing(
             recordName: recordName,
             zoneID: CKRecordZone.ID(zoneName: zoneName, ownerName: ownerName),
             databaseScope: friend.databaseScope
         )
     }
 
     // MARK: - Block
 
     /// Marks the friend blocked and tears down the channel so nothing further
     /// can arrive from them: the owner deletes the friend zone outright; a
     /// participant leaves by deleting the zone-wide share. The `FriendEntity`
     /// row is kept (as a blocked tombstone) so future `.invite` Pings are
     /// suppressed and the zone stays out of `knownZones`.
     func blockAndTeardown(friendAuthorID: String) async throws {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
         req.predicate = NSPredicate(format: "authorID == %@", friendAuthorID)
         req.fetchLimit = 1
         guard let friend = try ctx.fetch(req).first else { return }
         let scope = friend.databaseScope
         let zoneName = friend.friendZoneName
         let ownerName = friend.friendZoneOwnerName
         friend.isBlocked = true
         try ctx.save()
 
         // Make the block authoritative across the user's own devices. Written
         // before the channel teardown so the durable fact survives even a
         // partial teardown; `applyDecisionRecord` projects it onto a blocked
         // `FriendEntity` on every other device.
         await syncEngine.enqueueDecision(kind: "block", key: friendAuthorID)
 
         guard let zoneName, let ownerName else { return }
         let zoneID = CKRecordZone.ID(zoneName: zoneName, ownerName: ownerName)
         syncMonitor?.recordStart("block friend")
         do {
             if scope == 0 {
                 // We own the friend zone — deleting it revokes the share for
                 // both sides.
                 try await deleteZone(zoneID, in: container.privateCloudDatabase)
             } else {
                 // Participant — leave by deleting the zone-wide share record.
                 let shareID = CKRecord.ID(
                     recordName: CKRecordNameZoneWideShare,
                     zoneID: zoneID
                 )
                 do {
                     try await container.sharedCloudDatabase.deleteRecord(withID: shareID)
                 } catch let error as CKError
                     where error.code == .unknownItem || error.code == .zoneNotFound {
                     // Already gone — nothing to do.
                 }
             }
             syncMonitor?.recordSuccess("block friend")
         } catch {
             syncMonitor?.recordError("block friend", error)
         }
     }
 
     // MARK: - Rename
 
     /// Sets (or, with an empty string, clears) the user's private nickname
     /// for a friend. The nickname lives on the local `FriendEntity` and is
     /// made authoritative across the user's own devices via a versioned
     /// `nickname` Decision in the account zone — the same channel `block`
     /// rides; it is never written into the friend zone, so the friend never
     /// sees it. Each rename bumps the per-friend generation so the newest
     /// rename wins any cross-device race (`applyDecisionRecord`).
     func setNickname(friendAuthorID: String, nickname: String) async throws {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
         req.predicate = NSPredicate(format: "authorID == %@", friendAuthorID)
         req.fetchLimit = 1
         guard let friend = try ctx.fetch(req).first else {
             throw FriendError.friendNotFound
         }
         let trimmed = nickname.trimmingCharacters(in: .whitespacesAndNewlines)
         let version = friend.nicknameVersion + 1
         friend.nickname = trimmed.isEmpty ? nil : trimmed
         friend.nicknameVersion = version
         try ctx.save()
         FriendEntity.rebuildNicknameDirectory(in: ctx)
         // An empty payload propagates the clear: the Decision record stays
         // (preserving the version) but applies as "no nickname".
         await syncEngine.enqueueDecision(
             kind: RecordSerializer.nicknameDecisionKind,
             key: friendAuthorID,
             payload: trimmed.isEmpty ? nil : trimmed,
             version: version
         )
     }
 
     // MARK: - CloudKit helpers
 
     private func deleteZone(
         _ zoneID: CKRecordZone.ID,
         in database: CKDatabase
     ) async throws {
         try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
             let op = CKModifyRecordZonesOperation(
                 recordZonesToSave: nil,
                 recordZoneIDsToDelete: [zoneID]
             )
             op.qualityOfService = .userInitiated
             op.modifyRecordZonesResultBlock = { result in cont.resume(with: result) }
             database.add(op)
         }
     }
 
     private func createZone(_ zoneID: CKRecordZone.ID) async throws {
         try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
             let op = CKModifyRecordZonesOperation(
                 recordZonesToSave: [CKRecordZone(zoneID: zoneID)],
                 recordZoneIDsToDelete: nil
             )
             op.qualityOfService = .userInitiated
             op.modifyRecordZonesResultBlock = { result in cont.resume(with: result) }
             self.container.privateCloudDatabase.add(op)
         }
     }
 
     private func saveZoneWideShare(
         zoneID: CKRecordZone.ID,
         addingParticipant remoteAuthorID: String
     ) async throws -> CKShare {
         let share = CKShare(recordZoneID: zoneID)
         share.publicPermission = .none
         let participant = try await fetchParticipant(forUserRecordName: remoteAuthorID)
         participant.permission = .readWrite
         share.addParticipant(participant)
         let saved = try await container.privateCloudDatabase.save(share)
         guard let savedShare = saved as? CKShare else {
             throw FriendError.invalidShareRecord
         }
         return savedShare
     }
 
     /// The zone-wide `CKShare` for `zoneID` in our private database, or `nil`
     /// if it doesn't exist yet. Lets an owner-side device detect a friend zone
     /// a sibling device on the same iCloud account already shared.
     private func existingZoneWideShare(
         zoneID: CKRecordZone.ID
     ) async throws -> CKShare? {
         let shareID = CKRecord.ID(
             recordName: CKRecordNameZoneWideShare,
             zoneID: zoneID
         )
         do {
             let record = try await container.privateCloudDatabase.record(for: shareID)
             return record as? CKShare
         } catch let error as CKError
             where error.code == .unknownItem || error.code == .zoneNotFound {
             return nil
         }
     }
 
     private func fetchParticipant(
         forUserRecordName recordName: String
     ) async throws -> CKShare.Participant {
         let lookup = CKUserIdentity.LookupInfo(
             userRecordID: CKRecord.ID(recordName: recordName)
         )
         return try await withCheckedThrowingContinuation { cont in
             var found: CKShare.Participant?
             let op = CKFetchShareParticipantsOperation(userIdentityLookupInfos: [lookup])
             op.perShareParticipantResultBlock = { _, result in
                 if case .success(let participant) = result { found = participant }
             }
             op.fetchShareParticipantsResultBlock = { result in
                 switch result {
                 case .success:
                     if let found {
                         cont.resume(returning: found)
                     } else {
                         cont.resume(throwing: FriendError.participantNotFound)
                     }
                 case .failure(let error):
                     cont.resume(throwing: error)
                 }
             }
             self.container.add(op)
         }
     }
 
     private func fetchShareMetadata(url: URL) async throws -> CKShare.Metadata {
         try await withCheckedThrowingContinuation { cont in
             var metadata: CKShare.Metadata?
             let op = CKFetchShareMetadataOperation(shareURLs: [url])
             op.shouldFetchRootRecord = false
             op.perShareMetadataResultBlock = { _, result in
                 if case .success(let m) = result { metadata = m }
             }
             op.fetchShareMetadataResultBlock = { result in
                 switch result {
                 case .success:
                     if let metadata {
                         cont.resume(returning: metadata)
                     } else {
                         cont.resume(throwing: FriendError.invalidShareRecord)
                     }
                 case .failure(let error):
                     cont.resume(throwing: error)
                 }
             }
             self.container.add(op)
         }
     }
 
     private func accept(_ metadata: CKShare.Metadata) async throws {
         try await withCheckedThrowingContinuation { (cont: CheckedContinuation<Void, Error>) in
             let op = CKAcceptSharesOperation(shareMetadatas: [metadata])
             op.acceptSharesResultBlock = { result in cont.resume(with: result) }
             self.container.add(op)
         }
     }
 
     // MARK: - Core Data
 
     /// True if *any* `FriendEntity` for the pair exists — including a blocked
     /// one. This is deliberate for v1: a blocked friendship is permanent, so
     /// `establishIfOwner` / `applyFriendPing` short-circuit here and never
     /// re-bootstrap a channel the user has torn down. Re-friending a blocked
     /// collaborator is intentionally out of scope; lifting it later means
     /// adding an explicit unblock path, not changing this guard.
     private func friendExists(pairKey: String) -> Bool {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
         req.predicate = NSPredicate(format: "pairKey == %@", pairKey)
         req.fetchLimit = 1
         return ((try? ctx.count(for: req)) ?? 0) > 0
     }
 
     /// Records the friendship row. The display name is deliberately *not*
     /// written here — it arrives exclusively via the friend's `name` Decision
     /// (`RecordSerializer.applyDecisionRecord`); until that syncs, the invite
     /// surfaces fall back to the freshest per-game Player snapshot, then
     /// "Player".
     private func persistFriend(
         authorID: String,
         pairKey: String,
         zoneName: String,
         zoneOwnerName: String,
         databaseScope: Int16
     ) {
         let ctx = persistence.viewContext
         let req = NSFetchRequest<FriendEntity>(entityName: "FriendEntity")
         req.predicate = NSPredicate(format: "pairKey == %@", pairKey)
         req.fetchLimit = 1
         let entity = (try? ctx.fetch(req).first) ?? FriendEntity(context: ctx)
         entity.authorID = authorID
         entity.pairKey = pairKey
         entity.friendZoneName = zoneName
         entity.friendZoneOwnerName = zoneOwnerName
         entity.databaseScope = databaseScope
         if entity.createdAt == nil { entity.createdAt = Date() }
         do {
             try ctx.save()
             Task { [weak self] in
                 await self?.applyAccountNicknameDecisionIfPresent(for: authorID)
             }
         } catch {
             eventLog?.note("FriendController: persistFriend save failed — \(error)", level: "error")
         }
     }
 
     /// A sibling can set a nickname before this device has bootstrapped the
     /// `FriendEntity`. CKSyncEngine will then advance past the account-zone
     /// Decision without applying it because there is no friend row yet. After
     /// bootstrap creates the row, fetch the deterministic Decision directly
     /// and replay it once.
     func applyAccountNicknameDecisionIfPresent(for friendAuthorID: String) async {
         let recordName = RecordSerializer.decisionRecordName(
             kind: RecordSerializer.nicknameDecisionKind,
             key: friendAuthorID
         )
         let recordID = CKRecord.ID(
             recordName: recordName,
             zoneID: RecordSerializer.accountZoneID
         )
         do {
             let record = try await fetchAccountDecisionRecord(recordID)
             let ctx = persistence.viewContext
             let wrote = RecordSerializer.applyDecisionRecord(
                 record,
                 to: ctx,
                 localAuthorID: nil,
                 databaseScope: 0
             )
             if wrote {
                 try ctx.save()
                 FriendEntity.rebuildNicknameDirectory(in: ctx)
                 eventLog?.note(
                     "FriendController: replayed nickname decision \(recordName)",
                     level: "info"
                 )
             }
         } catch let error as CKError
             where error.code == .unknownItem || error.code == .zoneNotFound {
             // Most friendships will not have a private nickname yet.
         } catch {
             eventLog?.note(
                 "FriendController: nickname decision replay failed for \(friendAuthorID) — \(error)",
                 level: "error"
             )
         }
     }
 }