@glyphteck/veyl 0.70.0 → 0.71.0

package/dist/account.js

@@ -1127,6 +1127,16 @@ function numberToBytesBE(n, len) {
 function numberToBytesLE(n, len) {
   return numberToBytesBE(n, len).reverse();
 }
+function equalBytes(a, b) {
+  a = abytes2(a);
+  b = abytes2(b);
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0;i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
 function copyBytes(bytes) {
   return Uint8Array.from(abytes2(bytes));
 }
@@ -4813,7 +4823,7 @@ function checkOpts2(defaults, opts) {
   const merged = Object.assign(defaults, opts);
   return merged;
 }
-function equalBytes(a, b) {
+function equalBytes2(a, b) {
   a = abytes3(a);
   b = abytes3(b);
   if (a.length !== b.length)
@@ -5251,7 +5261,7 @@ var gcm = /* @__PURE__ */ wrapCipher({ blockSize: 16, nonceLength: 12, tagLength
       const passedTag = ciphertext.subarray(-tagLength);
       const tag = _computeTag(authKey, tagMask, data);
       toClean.push(tag);
-      if (!equalBytes(tag, passedTag)) {
+      if (!equalBytes2(tag, passedTag)) {
         clean2(...toClean);
         throw new Error("aes-gcm: invalid tag");
       }
@@ -5704,6 +5714,7 @@ var CHAT_TTL_CLIENT_DELETE_GRACE_MS = MINUTE_MS;
 var CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500;
 var CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250;
 var CHAT_LIST_PAGE_SIZE = 20;
+var CHAT_ADMISSION_CACHE_PEERS = 1024;
 var CHAT_LIST_LIVE_COUNT = CHAT_LIST_PAGE_SIZE;
 var CHAT_INBOX_PING_PAGE_SIZE = 25;
 var CHAT_INBOX_DISCOVERY_PARALLEL_CHATS = CHAT_INBOX_PING_PAGE_SIZE;
@@ -5877,9 +5888,12 @@ function normalizeChatNotificationMode(value, manifest) {
   const mode = cleanText(value);
   if (!NOTIFICATION_MODES.has(mode))
     throw new Error("chat notification mode required");
-  if (manifest?.lineage !== "group")
+  if (manifest?.lineage === "self")
     return CHAT_NOTIFICATION_MODES.ALL;
-  if (mode === CHAT_NOTIFICATION_MODES.ALL && manifest.members?.length > CHAT_ORDINARY_DELIVERY_MAX_MEMBERS) {
+  if (manifest?.lineage === "direct" && mode === CHAT_NOTIFICATION_MODES.MENTIONS) {
+    throw new Error("mentions notifications require a group chat");
+  }
+  if (mode === CHAT_NOTIFICATION_MODES.ALL && manifest?.lineage === "group" && manifest.members?.length > CHAT_ORDINARY_DELIVERY_MAX_MEMBERS) {
     return CHAT_NOTIFICATION_MODES.MENTIONS;
   }
   return mode;
@@ -6940,7 +6954,7 @@ var _poly1305_aead = (xorStream) => (key, nonce, AAD) => {
       const data = ciphertext.subarray(0, -tagLength);
       const passedTag = ciphertext.subarray(-tagLength);
       const tag = computeTag2(xorStream, key, nonce, data, AAD);
-      if (!equalBytes(passedTag, tag)) {
+      if (!equalBytes2(passedTag, tag)) {
         clean2(tag);
         throw new Error("invalid tag");
       }
@@ -8262,35 +8276,68 @@ function chatAdmissionCapabilityCommitment(value) {
     cleanBytes(capability);
   }
 }
-function directAdmissionCapabilityForPeer(chatPrivateKey, chatPK, profile) {
-  return deriveDirectAdmissionCapability(chatPrivateKey, chatPK, profile?.chatPK, profile?.chatPK);
-}
-function hasDirectAdmissionGrant(chatPrivateKey, chatPK, profile) {
-  const policy = normalizeChatAdmission(profile?.chatAdmission);
-  if (!policy.directGrants.length)
-    return false;
-  const capability = directAdmissionCapabilityForPeer(chatPrivateKey, chatPK, profile);
-  try {
-    return policy.directGrants.includes(chatAdmissionCapabilityCommitment(capability));
-  } finally {
-    cleanBytes(capability);
-  }
+function deriveDirectAdmissionCommitment(chatPrivateKey, chatPK, peerChatPK, recipientChatPK) {
+  return chatAdmissionCapabilityCommitment(deriveDirectAdmissionCapability(chatPrivateKey, chatPK, peerChatPK, recipientChatPK));
 }
-function directAdmissionForPeer(chatPrivateKey, chatPK, profile, ownAdmission = null) {
-  if (ownAdmission != null && normalizeChatAdmission(ownAdmission).direct === CHAT_DIRECT_ADMISSION_MODES.CLOSED && incomingChatAdmissionDecision(chatPrivateKey, chatPK, profile, ownAdmission, "direct") !== CHAT_ADMISSION_DECISIONS.ACCEPT)
+function directAdmissionDecision(chatPK, profile, ownAdmission, commitmentFor) {
+  const ownPolicy = normalizeChatAdmission(ownAdmission);
+  if (ownAdmission != null && ownPolicy.direct === CHAT_DIRECT_ADMISSION_MODES.CLOSED && !ownPolicy.directGrants.includes(commitmentFor(profile?.chatPK, chatPK)))
     return CHAT_ADMISSION_DECISIONS.REJECT;
-  if (hasDirectAdmissionGrant(chatPrivateKey, chatPK, profile)) {
+  const policy = normalizeChatAdmission(profile?.chatAdmission);
+  if (policy.directGrants.length && policy.directGrants.includes(commitmentFor(profile?.chatPK, profile?.chatPK))) {
     return CHAT_ADMISSION_DECISIONS.ACCEPT;
   }
-  const mode = normalizeChatAdmission(profile?.chatAdmission).direct;
+  const mode = policy.direct;
   if (mode === CHAT_DIRECT_ADMISSION_MODES.OPEN)
     return CHAT_ADMISSION_DECISIONS.ACCEPT;
   if (mode === CHAT_DIRECT_ADMISSION_MODES.REQUESTS)
     return CHAT_ADMISSION_DECISIONS.REQUEST;
   return CHAT_ADMISSION_DECISIONS.REJECT;
 }
-function canStartDirectChat(chatPrivateKey, chatPK, profile, ownAdmission = null) {
-  return directAdmissionForPeer(chatPrivateKey, chatPK, profile, ownAdmission) !== CHAT_ADMISSION_DECISIONS.REJECT;
+function directAdmissionForPeer(chatPrivateKey, chatPK, profile, ownAdmission = null) {
+  return directAdmissionDecision(chatPK, profile, ownAdmission, (peerChatPK, recipientChatPK) => deriveDirectAdmissionCommitment(chatPrivateKey, chatPK, peerChatPK, recipientChatPK));
+}
+function createChatAdmission({ getIdentity, deriveCommitment = deriveDirectAdmissionCommitment }) {
+  let chatPK = null;
+  let privateKey = null;
+  let privateKeyBytes = null;
+  const peers = new Map;
+  const reset = () => {
+    peers.clear();
+    cleanBytes(privateKeyBytes);
+    chatPK = null;
+    privateKey = null;
+    privateKeyBytes = null;
+  };
+  const directAdmissionForPeer2 = (profile) => {
+    const identity = getIdentity();
+    if (chatPK !== identity.chatPK || privateKey !== identity.chatPrivateKey || privateKey instanceof Uint8Array && !equalBytes(privateKey, privateKeyBytes)) {
+      reset();
+      chatPK = identity.chatPK;
+      privateKey = identity.chatPrivateKey;
+      privateKeyBytes = privateKey instanceof Uint8Array ? new Uint8Array(privateKey) : null;
+    }
+    return directAdmissionDecision(chatPK, profile, identity.chatAdmission, (peerChatPK, recipientChatPK) => {
+      let commitments = peers.get(peerChatPK);
+      if (!commitments?.has(recipientChatPK)) {
+        const commitment = deriveCommitment(privateKey, chatPK, peerChatPK, recipientChatPK);
+        if (!commitments) {
+          commitments = new Map;
+          if (peers.size >= CHAT_ADMISSION_CACHE_PEERS)
+            peers.delete(peers.keys().next().value);
+        }
+        commitments.set(recipientChatPK, commitment);
+      }
+      peers.delete(peerChatPK);
+      peers.set(peerChatPK, commitments);
+      return commitments.get(recipientChatPK);
+    });
+  };
+  return {
+    directAdmissionForPeer: directAdmissionForPeer2,
+    canStartDirectChat: (profile) => directAdmissionForPeer2(profile) !== CHAT_ADMISSION_DECISIONS.REJECT,
+    reset
+  };
 }
 function canInviteToGroup(profile, ownAdmission = null) {
   return (ownAdmission == null || normalizeChatAdmission(ownAdmission).groups === CHAT_GROUP_ADMISSION_MODES.OPEN) && normalizeChatAdmission(profile?.chatAdmission).groups === CHAT_GROUP_ADMISSION_MODES.OPEN;
@@ -10394,6 +10441,26 @@ function transitionCore(certificate) {
   return normalizeTransitionCore(certificate);
 }
 
+// ../../core/chat/capabilities.js
+function memberCount(value) {
+  const count = Number(value);
+  if (!Number.isSafeInteger(count) || count < 1 || count > CHAT_MAX_MEMBERS) {
+    throw new Error("invalid chat member count");
+  }
+  return count;
+}
+function chatCapabilities(value) {
+  const members = memberCount(value);
+  return Object.freeze({
+    members,
+    sharedReceipts: members <= CHAT_RECEIPT_MAX_MEMBERS,
+    ordinaryDelivery: members <= CHAT_ORDINARY_DELIVERY_MAX_MEMBERS
+  });
+}
+function chatEpochCapabilities(epochState) {
+  return chatCapabilities(epochState?.manifest?.members?.length);
+}
+
 // ../../core/chat/ttl.js
 "use client";
 var CHAT_RETENTION_SEEN = "seen";
@@ -10406,6 +10473,10 @@ var CHAT_RETENTION_LABELS = Object.freeze({
   [CHAT_RETENTION_SEEN]: "delete after seen",
   [CHAT_RETENTION_24H]: "keep for 24h"
 });
+var CHAT_RETENTION_DESCRIPTIONS = Object.freeze({
+  [CHAT_RETENTION_SEEN]: "messages now delete after being seen",
+  [CHAT_RETENTION_24H]: "messages now delete 24h after being seen"
+});
 var MESSAGE_STORAGE_TTL_MS = CHAT_UNSAVED_TTL_MS;
 var AFTER_SEEN_MS = CHAT_AFTER_SEEN_MS;
 function hasChatRetention(value) {
@@ -11068,6 +11139,8 @@ async function prepareOwnChatMutation(identity, entryId, current, update) {
     open: (record) => openOwnChatMutationEntry(identity, entryId, record),
     prepare: async (record) => {
       if (!record) {
+        if (current != null)
+          throw makeChatUnavailableError();
         return prepareMutation(identity, entryId, null, update);
       }
       if (!record?.body || !Number.isSafeInteger(record.revision) || record.revision < 1) {
@@ -11827,26 +11900,6 @@ async function openChatMemberState(epoch, record) {
   return evidence.state;
 }
 
-// ../../core/chat/capabilities.js
-function memberCount(value) {
-  const count = Number(value);
-  if (!Number.isSafeInteger(count) || count < 1 || count > CHAT_MAX_MEMBERS) {
-    throw new Error("invalid chat member count");
-  }
-  return count;
-}
-function chatCapabilities(value) {
-  const members = memberCount(value);
-  return Object.freeze({
-    members,
-    sharedReceipts: members <= CHAT_RECEIPT_MAX_MEMBERS,
-    ordinaryDelivery: members <= CHAT_ORDINARY_DELIVERY_MAX_MEMBERS
-  });
-}
-function chatEpochCapabilities(epochState) {
-  return chatCapabilities(epochState?.manifest?.members?.length);
-}
-
 // ../../core/chat/memberstate.js
 "use client";
 function openStateEpoch(epochState, actor = null) {
@@ -12987,7 +13040,8 @@ function getMsgReactions(msg) {
       continue;
     }
     seen.add(user);
-    reactions.push({ emoji, user });
+    const ts = timestampMs(item.ts, null);
+    reactions.push({ emoji, user, ...ts == null ? {} : { ts } });
     if (reactions.length >= MAX_REACTIONS) {
       break;
     }
@@ -13864,7 +13918,7 @@ function senderIdentity(senderChatPK, senderPrivateKey, options) {
     notificationPrivateKey: options.notificationPrivateKey
   };
 }
-function ownerPreview(senderChatPK, message, messageId, head, tsMs, ttlMs) {
+function ownerPreview(epoch, senderChatPK, message, messageId, head, tsMs, ttlMs) {
   return {
     ...message || {},
     s: senderChatPK,
@@ -13873,6 +13927,8 @@ function ownerPreview(senderChatPK, message, messageId, head, tsMs, ttlMs) {
     id: messageId,
     ts: tsMs,
     ttl: Number.isFinite(ttlMs) ? ttlMs : null,
+    epochId: epoch.epochId,
+    epochMemberChatPKs: epoch.manifest.members.map((member) => member.chatPK),
     pending: false,
     failed: false
   };
@@ -14089,7 +14145,7 @@ async function prepareMsgRecord(identity, epochState, message, options = {}) {
       msgId: messageId,
       cid: head.cid,
       record: { lane: epoch.messageLane, head, body, ttlMs },
-      message: ownerPreview(identity.chatPK, messagePayload, messageId, head, tsMs, ttlMs),
+      message: ownerPreview(epoch, identity.chatPK, messagePayload, messageId, head, tsMs, ttlMs),
       mentionRecipientChatPKs: mentionTargets.recipientChatPKs,
       tsMs
     };
@@ -18368,12 +18424,6 @@ function dropCachedChats(cache, chatIds, currentPayload = null) {
     ...ids.map((chatId) => dropCachedMessageState(cache, chatId))
   ]));
 }
-function dropCachedChat(cache, chatId) {
-  if (!chatId) {
-    return;
-  }
-  dropCachedChats(cache, [chatId]);
-}
 // ../../core/cache/localdata/balance.js
 "use client";
 function normalizedBalance(value) {
@@ -22547,6 +22597,17 @@ function createRouteMemory(limit = CHAT_MESSAGE_VIEW_CACHE_SIZE) {
   }
   return {
     clear,
+    dropChat(chatId) {
+      const id = String(chatId || "").trim();
+      if (!id)
+        return;
+      const keys = chatRouteMemoryKeys(id, [...states.keys(), ...retained.keys()]);
+      for (const key of keys) {
+        states.delete(key);
+        retained.delete(key);
+      }
+      activeChats.delete(id);
+    },
     resetAccount(nextAccountKey) {
       const next = nextAccountKey || "";
       if (accountKey === next) {
@@ -24099,6 +24160,9 @@ async function verifyOpenedPingEpoch(context) {
     const decision = await decideIncomingChat(context, epochState);
     if (decision === CHAT_ADMISSION_DECISIONS.REJECT)
       return "rejected";
+    const unavailable = await checkOpenedWelcomeAvailability(context);
+    if (unavailable)
+      return unavailable;
     if (decision === CHAT_ADMISSION_DECISIONS.REQUEST)
       return "request";
   } else if (context.entry && (epochState.manifest.lineage === "direct" || epochState.manifest.lineage === "group")) {
@@ -24108,6 +24172,27 @@ async function verifyOpenedPingEpoch(context) {
   }
   return null;
 }
+async function checkOpenedWelcomeAvailability(context) {
+  const { cloud, identity, options, uid, epochState } = context;
+  assertInboxLease(options);
+  try {
+    await cloud.chat.state.transition(epochState.manifest.chatId, epochState.manifest.epochId, epochState.stateCapability);
+    assertInboxLease(options);
+    return null;
+  } catch (error) {
+    const code = cleanText(error?.code).toLowerCase();
+    if (code !== "permission-denied" && !code.endsWith("/permission-denied"))
+      throw error;
+    try {
+      await retireConfirmedDeletedChat(cloud, uid, identity, context.committedEntry || context.entry || makeOwnChatEntry(epochState), options);
+      return "deleted";
+    } catch (confirmationError) {
+      if (isRetryableInboxError(confirmationError))
+        throw confirmationError;
+      throw error;
+    }
+  }
+}
 function startOpenedWelcomeHydration(context) {
   const membershipWelcome = (!context.entry || context.restoringMembership) && context.payload.kind === "welcome";
   if (!membershipWelcome)
@@ -24344,17 +24429,30 @@ async function settleOpenedPing(prepared, onAuthoritative) {
   const createsMembership = !context.entry && context.payload.kind === "welcome";
   const ownerPersistence = createsMembership ? captureAsync(persistOpenedPingOwner(context)) : null;
   const messageStartedAt = Date.now();
-  const result = await applyOpenedPingMessage(context);
+  const messageOutcome = await captureAsync(applyOpenedPingMessage(context));
   markDiag(context.options.diag, "chat.inbox.settle.message.done", {
     elapsedMs: Date.now() - messageStartedAt
   });
-  if (result)
-    return result;
-  prepareOpenedPingActivity(context);
   if (ownerPersistence)
     await unwrapAsync(ownerPersistence);
-  else
-    await persistOpenedPingOwner(context);
+  else if (messageOutcome.error)
+    throw messageOutcome.error;
+  if (messageOutcome.value)
+    return messageOutcome.value;
+  if (!messageOutcome.error) {
+    prepareOpenedPingActivity(context);
+    if (!ownerPersistence)
+      await persistOpenedPingOwner(context);
+  }
+  if (context.membershipWelcome) {
+    const unavailable = await checkOpenedWelcomeAvailability(context);
+    if (unavailable) {
+      await cleanupOpenedPing(context);
+      return unavailable;
+    }
+  }
+  if (messageOutcome.error)
+    throw messageOutcome.error;
   publishOpenedPing(context);
   onAuthoritative?.();
   const phaseStartedAt = Date.now();
@@ -24481,6 +24579,7 @@ async function preparePreparedPing(cloud, uid, identity, prepared, options) {
       ping,
       uid
     });
+    assertInboxLease(options);
     return { opened, releaseMutation };
   } catch (error) {
     releaseMutation();
@@ -24935,10 +25034,11 @@ async function prepareInboxWork(context, prepared, processingOptions = {}) {
   const { blockedUids, cloud, identity, options, state, uid } = context;
   const { document, opened } = prepared;
   let announcement = null;
+  let ping = null;
   try {
     const authenticated = await authenticateInboxPing(cloud, identity, document, opened, state.currentChats, context.profileCache);
     assertInboxLease(options);
-    const ping = await preparePreparedPing(cloud, uid, identity, authenticated, {
+    ping = await preparePreparedPing(cloud, uid, identity, authenticated, {
       ...options,
       blockedUids,
       currentChats: state.currentChats,
@@ -24955,9 +25055,11 @@ async function prepareInboxWork(context, prepared, processingOptions = {}) {
     if (ping.opened?.result === "request") {
       await hydrateOpenedChatRequest(ping.opened.context);
     }
+    assertInboxLease(options);
     announcement = announcePreparedWelcome(context, authenticated, ping, document, prepared.startedAt);
     return { announcement, document, ping, prepared, processingOptions, status: null };
   } catch (error) {
+    ping?.releaseMutation();
     state.revokeAnnouncement(announcement);
     if (processingOptions.deferUnknownWelcome === true && error?.message === "chat mls welcome required") {
       markDiag(options.diag, "chat.inbox.document.deferred", { reason: "welcome_required" });
@@ -25085,6 +25187,8 @@ function createInboxSettlementController(options = {}) {
     for (const job of lane.jobs) {
       if (job.settled)
         continue;
+      if (job.state === "ready")
+        job.discard?.(job.prepared);
       job.settled = true;
       job.state = "settled";
       job.deferred.reject(error);
@@ -25129,9 +25233,12 @@ function createInboxSettlementController(options = {}) {
     }
     job.state = "preparing";
     Promise.resolve().then(job.prepare).then((prepared) => {
-      if (job.settled)
+      if (job.settled) {
+        job.discard?.(prepared);
         return;
+      }
       if (!hasLease()) {
+        job.discard?.(prepared);
         finishJob(job, inboxLeaseError());
         return;
       }
@@ -25152,6 +25259,7 @@ function createInboxSettlementController(options = {}) {
       if (!job || job.settled)
         continue;
       if (!hasLease()) {
+        job.discard?.(job.prepared);
         finishJob(job, inboxLeaseError());
         continue;
       }
@@ -25187,6 +25295,7 @@ function createInboxSettlementController(options = {}) {
     const job = {
       chatId,
       deferred: inboxDeferred(),
+      discard: task.discard,
       lane,
       prepare: task.prepare,
       prepared: null,
@@ -25244,6 +25353,10 @@ async function processInboxDocuments(context, documents, processingOptions = {})
   const deferred = [];
   await Promise.all(groups.map((group) => context.settlementController.schedule(cleanText(group[0]?.opened?.payload?.chatId), {
     prepare: () => context.discoveryPool.run(() => prepareInboxWork(context, group[0], processingOptions)),
+    discard: (work) => {
+      work?.ping?.releaseMutation();
+      context.state.revokeAnnouncement(work?.announcement);
+    },
     settle: async (first, markAuthoritative) => {
       if (await settleInboxWork(context, first, markAuthoritative) === "deferred")
         deferred.push(first.document);
@@ -25531,6 +25644,7 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
           nextAfterChat: snapshot.nextAfterChat,
           hasMore: snapshot.hasMore,
           ownerListToken: snapshot.ownerListToken,
+          sourceRevision: snapshot.sourceRevision,
           source: "server"
         });
         deleteConfirmedUserChats(cloud, uid, page.deletedEntryIds);
@@ -25755,7 +25869,8 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
     latestOwnerSnapshot = {
       docs: entries,
       nextAfterChat: meta.nextAfterChat ?? null,
-      hasMore: !!meta.hasMore
+      hasMore: !!meta.hasMore,
+      sourceRevision: options.getSourceRevision?.()
     };
     queueOwnerSnapshot();
   }, onError, { limitCount: pageSize });
@@ -26246,15 +26361,15 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
   const ownerFor = (entry) => composeActivity(structuralOwnerFor(entry), entry);
   const cacheFor = (entry) => composeActivity(entry?.cache, entry);
   const sourceCanPublish = (chat, sourceRevision) => {
+    const boundary = authorityBoundaries.get(chat?.id);
+    if (boundary?.terminal)
+      return false;
     if (!chat?.id || !Number.isSafeInteger(sourceRevision))
       return true;
     if (sourceRevision < sourceRevisionFloor)
       return false;
-    const boundary = authorityBoundaries.get(chat.id);
     if (!boundary)
       return true;
-    if (boundary.terminal)
-      return false;
     return sourceRevision >= boundary.revision || compareOwners(chat, boundary.owner) > 0;
   };
   const sourceCanRemove = (chatId, sourceRevision) => {
@@ -26394,21 +26509,33 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     updatePeers(shown);
     return shown;
   };
+  const clearRemovedOwners = (chatIds) => {
+    if (!chatIds.length)
+      return;
+    const sources = getSources();
+    for (const chatId of chatIds)
+      sources.pendingDeleteIdsRef.current.delete(chatId);
+    sources.onOwnerRemoved?.(chatIds);
+    cache.removeMany(chatIds);
+    const removedIds = new Set(chatIds);
+    sources.setSelectedChat((current) => removedIds.has(current) ? null : current);
+  };
   const convergeCompleteOwnerSet = (incomingIds = null, sourceRevision = null) => {
-    const evictedCacheIds = [];
+    const removedIds = [];
     for (const [chatId, entry] of entries) {
-      if (!entry.observedOwner && !entry.committedOwner && !entry.announcement) {
-        if (!sourceCanRemove(chatId, sourceRevision))
-          continue;
-        recordTerminal(chatId, cacheFor(entry));
-        if (entry.cache)
-          evictedCacheIds.push(chatId);
-        entries.delete(chatId);
-      } else if (!incomingIds || !incomingIds.has(chatId)) {
+      if (incomingIds ? incomingIds.has(chatId) : entry.observedOwner)
+        continue;
+      if (!sourceCanRemove(chatId, sourceRevision))
+        continue;
+      if (entry.announcement && !authorityBoundaries.get(chatId)?.owner) {
         entry.cache = null;
+        continue;
       }
+      recordTerminal(chatId, ownerFor(entry) || cacheFor(entry));
+      entries.delete(chatId);
+      removedIds.push(chatId);
     }
-    cache.removeMany(evictedCacheIds);
+    clearRemovedOwners(removedIds);
   };
   const observeOwnerChats = (rows, options = {}) => {
     const incoming = (rows || []).filter((chat) => chat?.id && sourceCanPublish(chat, options.sourceRevision));
@@ -26484,6 +26611,8 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
   const announceWelcome = (announcement) => {
     if (!announcement?.chatId || !announcement?.token)
       return false;
+    if (authorityBoundaries.get(announcement.chatId)?.terminal)
+      return false;
     const sources = getSources();
     if (sources.pendingDeleteIdsRef.current.has(announcement.chatId))
       return false;
@@ -26520,7 +26649,6 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
       return false;
     if (!sourceCanRemove(chatId, options.sourceRevision))
       return false;
-    recordTerminal(chatId, cacheFor(entry));
     entry.cache = null;
     entry.presentation = null;
     cache.remove(chatId);
@@ -26530,15 +26658,12 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
     return true;
   };
   const removeOwner = (chatId, options = {}) => {
-    const sources = getSources();
     if (!chatId)
       return false;
     recordTerminal(chatId, ownerFor(entries.get(chatId)) || cacheFor(entries.get(chatId)));
-    sources.pendingDeleteIdsRef.current.delete(chatId);
     const removed = entries.delete(chatId);
-    cache.remove(chatId);
+    clearRemovedOwners([chatId]);
     publishOwners({ ...options, warm: false });
-    sources.setSelectedChat((current) => current === chatId ? null : current);
     return removed;
   };
   const removeInboxOwner = (chatId, options = {}) => {
@@ -26886,7 +27011,7 @@ function createChatListListener({
         sync();
       }, CHAT_LIST_LISTENER_RETRY_MS);
     };
-    const subscription = subscribe(sources.cloud, sources.uid, sources.chatPK, sources.chatPrivateKey, (nextChats, _nextPeers, meta = {}) => handleUpdate(nextChats, meta, listenStartedAt, index.getAuthorityRevision()), (error) => {
+    const subscription = subscribe(sources.cloud, sources.uid, sources.chatPK, sources.chatPrivateKey, (nextChats, _nextPeers, meta = {}) => handleUpdate(nextChats, meta, listenStartedAt, meta.sourceRevision), (error) => {
       const current = getSources();
       state.setIsChatListLive(false);
       markError(current.diag, "chat.provider.listen", listenStartedAt, error);
@@ -26897,6 +27022,7 @@ function createChatListListener({
       retry(error);
     }, {
       limitCount: CHAT_LIST_LIVE_COUNT,
+      getSourceRevision: index.getAuthorityRevision,
       onInboxAnnouncement: index.announceWelcome,
       onInboxRevoke: index.revokeAnnouncement,
       onInboxCommit: index.commitOwner,
@@ -28343,6 +28469,7 @@ async function createGroupChat(cloud, identityValue, memberValues, settings = {}
   if (!identity.chatSigningSecret)
     throw new Error("unlocked chat signing identity required");
   const mls = await lifecycle.mls?.open?.();
+  lifecycle.assertCurrent?.();
   if (!mls)
     throw new Error("mls engine required");
   const selfLeafId = lifecycle.selfLeafId || randomBytes3(32);
@@ -28363,7 +28490,7 @@ async function createGroupChat(cloud, identityValue, memberValues, settings = {}
   if (additions.length)
     mlsGroup = await mls.stageChange(mlsGroup.snapshot, { adds: additions });
   const material = deriveChatMlsEpochMaterial(mlsGroup.epochKey, { chatId, epochVersion: 1 });
-  const lineage = members.length === 1 ? CHAT_LINEAGES.SELF : members.length === 2 ? CHAT_LINEAGES.DIRECT : CHAT_LINEAGES.GROUP;
+  const lineage = lifecycle.lineage || (members.length === 1 ? CHAT_LINEAGES.SELF : members.length === 2 ? CHAT_LINEAGES.DIRECT : CHAT_LINEAGES.GROUP);
   const manifest = makeInitialEpochManifest({
     chatId,
     epochId: material.epochId,
@@ -28426,6 +28553,7 @@ async function createGroupChat(cloud, identityValue, memberValues, settings = {}
     });
     initial.backend.membershipOutbox = queuedWelcomes.map(({ outboxId: outboxId2, sealed }) => ({ outboxId: outboxId2, sealed }));
     stage = "owner";
+    lifecycle.assertCurrent?.();
     const registration = registerInitialDelivery(cloud, identity, initialState);
     const stateId = chatMlsStateId(identity.chatPrivateKey, chatId, initial.transitionCommitment);
     const ownerMlsState = await sealChatMlsState(identity.chatPrivateKey, stateId, { v: 1, chatId, transitionCommitment: initial.transitionCommitment }, mlsGroup.snapshot);
@@ -28437,6 +28565,8 @@ async function createGroupChat(cloud, identityValue, memberValues, settings = {}
     let stateError = null;
     try {
       stage = "state";
+      lifecycle.assertCurrent?.();
+      lifecycle.onCreateDispatched?.(initial.manifest.chatId);
       await cloud.chat.state.create({
         ...initial.backend,
         ownerEntry: owner.write,
@@ -28771,21 +28901,23 @@ function createChatSessionLaunches({
     if (!opened?.chatId || !opened?.entry)
       return "";
     const chat = projectOwnChatEntry(opened.entry, opened.entryId || "", operation.identity.chatPK, opened.tsMs || Date.now());
-    operation.listOwner.commitOwner(chat);
+    if (!operation.listOwner.commitOwner(chat))
+      throw makeChatUnavailableError();
     return opened.chatId;
   };
   const presentOpenedChat = (opened, operation) => {
     assertCurrent(operation);
     if (!opened?.chatId || !opened?.entry)
       return "";
-    operation.pendingOwner.adoptOpenedChatId(opened.chatId);
     const chatId = commitOpenedChat(opened, operation);
+    operation.pendingOwner.adoptOpenedChatId(chatId);
     pendingPeerSelect = null;
     setSelectedChat(chatId);
     return chatId;
   };
   const createChat = async (profiles, settings, lifecycle, adoptOpenedChat, operation, { profilesCurrent = false } = {}) => {
     assertCurrent(operation);
+    lifecycle.assertCurrent?.();
     const { blocked, chatPK, chatPrivateKey } = operation.identity;
     let profileList = Array.isArray(profiles) ? profiles : [profiles];
     if (!profilesCurrent && profileList.length) {
@@ -28793,9 +28925,10 @@ function createChatSessionLaunches({
     }
     const blockedSet = new Set(blocked);
     const requestedMembers = profileList.map(profileMember);
-    if (profileList.length === 1) {
+    const expectedLineage = lifecycle.lineage || (requestedMembers.length === 0 ? "self" : requestedMembers.length === 1 ? "direct" : "group");
+    if (expectedLineage === "direct") {
       assertDirectAdmission(profileList[0], operation);
-    } else if (profileList.length > 1) {
+    } else if (expectedLineage === "group") {
       if (normalizeChatAdmission(operation.identity.chatAdmission).groups === CHAT_GROUP_ADMISSION_MODES.CLOSED) {
         throw new Error("group chats are closed");
       }
@@ -28809,8 +28942,7 @@ function createChatSessionLaunches({
       if (blockedSet.has(member.uid))
         throw new Error("blocked peer cannot be added");
     }
-    const canonicalChatId = lifecycle.chatId || (requestedMembers.length === 0 ? deriveSelfChatId(chatPrivateKey, chatPK) : "");
-    const expectedLineage = requestedMembers.length === 0 ? "self" : requestedMembers.length === 1 ? "direct" : "group";
+    const canonicalChatId = lifecycle.chatId || (expectedLineage === "self" ? deriveSelfChatId(chatPrivateKey, chatPK) : "");
     const expectedMemberKeys = [chatPK, ...requestedMembers.map((member) => member.chatPK)].sort();
     const matchingExistingChat = () => {
       assertCurrent(operation);
@@ -28849,6 +28981,7 @@ function createChatSessionLaunches({
     markDiag(diag, "chat.group.create.prekeys.start", { members: requestedMembers.length });
     const additions = await prepareMlsAdditions(profileList);
     assertCurrent(operation);
+    lifecycle.assertCurrent?.();
     markDiag(diag, "chat.group.create.prekeys.done", { members: requestedMembers.length, elapsedMs: Date.now() - prekeyStartedAt });
     if (!additions.length && requestedMembers.length)
       throw new Error("peer mls key package required");
@@ -28858,15 +28991,23 @@ function createChatSessionLaunches({
       const created = await createGroupChat(cloud, operation.transitionIdentity, [...byKey.values()], settings, {
         mls,
         chatId: canonicalChatId || undefined,
+        lineage: expectedLineage,
         wakeMessageId: lifecycle.wakeMessageId,
+        assertCurrent: () => {
+          assertCurrent(operation);
+          lifecycle.assertCurrent?.();
+        },
+        onCreateDispatched: lifecycle.onCreateDispatched,
         onStateReady: (opened) => {
           assertCurrent(operation);
+          lifecycle.assertCurrent?.();
           stateReady = true;
           const chatId = adoptOpenedChat(opened);
           lifecycle.onStateReady?.(chatId, opened, { created: true });
         },
         onOwnerReady: async (opened) => {
           assertCurrent(operation);
+          lifecycle.assertCurrent?.();
           const chatId = adoptOpenedChat(opened);
           const result = await lifecycle.onOwnerReady?.(chatId, opened, { created: true });
           assertCurrent(operation);
@@ -28877,7 +29018,7 @@ function createChatSessionLaunches({
       return adoptOpenedChat(created);
     } catch (error) {
       assertCurrent(operation);
-      if (stateReady || !canonicalChatId || requestedMembers.length > 0)
+      if (stateReady || !canonicalChatId)
         throw error;
       await ensureChat(canonicalChatId);
       assertCurrent(operation);
@@ -28891,6 +29032,10 @@ function createChatSessionLaunches({
     const operation = operationContext();
     return createChat(profiles, settings, lifecycle, (opened) => presentOpenedChat(opened, operation), operation);
   };
+  const materializeGroupChat = (profiles, settings = {}, lifecycle = {}) => {
+    const operation = operationContext();
+    return createChat(profiles, settings, lifecycle, (opened) => commitOpenedChat(opened, operation), operation);
+  };
   const runExistingDirectLifecycle = async (chatId, lifecycle, operation) => {
     assertCurrent(operation);
     const existing = getOwnerChat(chatId);
@@ -28962,6 +29107,7 @@ function createChatSessionLaunches({
     getOpenOperation: (chatId) => directOpens.get(chatId)?.promise || null,
     getPeerChatId,
     materializeDirectChat,
+    materializeGroupChat,
     openDirectChat,
     openNotesChat,
     releaseOpenOperation: (chatId) => {
@@ -29026,16 +29172,21 @@ function createChatSessionPending({
   getPeerProfile,
   resolvePeerProfile,
   setLocalByChat,
-  getLocalByChat = () => new Map
+  getLocalByChat = () => new Map,
+  retireMaterializedChat = () => {}
 }) {
+  const admission = createChatAdmission({ getIdentity });
   let pendingLaunch = null;
   const pendingOperations = new Map;
   let generation = 0;
+  const operationForChat = (chatId) => pendingOperations.get(chatId) || [...pendingOperations.values()].find((state) => state.canonicalChatId === chatId) || null;
+  const launchForChat = (chatId) => pendingLaunch && [pendingLaunch.id, pendingLaunch.canonicalChatId].includes(chatId) ? pendingLaunch : operationForChat(chatId)?.launch || storedLaunch(chatId);
   const storedLaunch = (chatId) => getLocalByChat().get(chatId)?.find((message) => message.chatDraft)?.chatDraft || null;
   const getPendingLaunch = () => {
     if (!pendingLaunch)
       return null;
-    const messages = getLocalByChat().get(pendingLaunch.id) || [];
+    const localByChat = getLocalByChat();
+    const messages = localByChat.get(pendingLaunch.id) || localByChat.get(pendingLaunch.canonicalChatId) || [];
     const message = messages[messages.length - 1] || null;
     return { ...pendingLaunch, messages, message, chat: {
       ...pendingLaunch.chat,
@@ -29043,23 +29194,33 @@ function createChatSessionPending({
       ts: message ? timestampMs(message.ts, null) : null
     } };
   };
+  const resolvePendingChatId = (chatId) => {
+    const canonicalId = operationForChat(chatId)?.canonicalChatId || launchForChat(chatId)?.canonicalChatId;
+    return canonicalId && getOwnerChat(canonicalId) ? canonicalId : chatId;
+  };
   const finish = (launchId) => {
     if (pendingLaunch?.id !== launchId)
       return;
+    if (pendingLaunch.canonicalChatId !== launchId) {
+      publish();
+      return;
+    }
     pendingLaunch = null;
     pendingOperations.delete(launchId);
     publish();
   };
   const track = (launchId, operation) => {
     const tracked = Promise.resolve(operation);
-    pendingOperations.set(launchId, tracked);
+    const state = pendingOperations.get(launchId) || { active: true, promise: null };
+    state.promise = tracked;
+    pendingOperations.set(launchId, state);
     tracked.then(() => {
-      if (pendingOperations.get(launchId) !== tracked)
+      if (pendingOperations.get(launchId) !== state || state.promise !== tracked)
         return;
       pendingOperations.delete(launchId);
       finish(launchId);
     }, () => {
-      if (pendingOperations.get(launchId) !== tracked)
+      if (pendingOperations.get(launchId) !== state || state.promise !== tracked)
         return;
       pendingOperations.delete(launchId);
       if (pendingLaunch?.id !== launchId)
@@ -29071,6 +29232,12 @@ function createChatSessionPending({
     });
     return tracked;
   };
+  const cancelOperation = (launchId) => {
+    const operation = pendingOperations.get(launchId);
+    if (operation)
+      operation.active = false;
+    pendingOperations.delete(launchId);
+  };
   const show = (launch) => {
     if (pendingLaunch?.id && pendingLaunch.id !== launch.id && !pendingOperations.has(pendingLaunch.id)) {
       getRouteOwner().releaseOpenOperation?.(pendingLaunch.id);
@@ -29166,7 +29333,7 @@ function createChatSessionPending({
       return cached;
     return (fallbackProfiles || []).find((profile) => profileMatchesPeer(profile, peer)) || null;
   };
-  const profileAcceptsDirect = (identity, profile) => !!identity?.chatPK && !!identity?.chatPrivateKey && directAdmissionForPeer(identity.chatPrivateKey, identity.chatPK, profile, identity.chatAdmission) !== CHAT_ADMISSION_DECISIONS.REJECT;
+  const profileAcceptsDirect = (identity, profile) => !!identity?.chatPK && !!identity?.chatPrivateKey && admission.directAdmissionForPeer(profile) !== CHAT_ADMISSION_DECISIONS.REJECT;
   const isChatAdmitted = (chat, fallbackProfiles = []) => {
     const identity = getIdentity();
     if (!chat)
@@ -29299,18 +29466,29 @@ function createChatSessionPending({
       throw error;
     }
   };
-  const sendDurableAttachment = async (chatId, attachment, options = {}) => {
-    const target = await admittedSendTarget(chatId, options);
-    return getSendActions().sendAttachment(target.routeAnchor, attachment, target.options);
-  };
-  const sendDurableSharedAttachment = async (chatId, attachment, options = {}) => {
+  const withReadyAttachmentTarget = async (chatId, options, send) => {
+    const attemptGeneration = generation;
+    await waitForSend(chatId, { expiresAt: options.expiresAt, signal: options.signal });
+    if (attemptGeneration !== generation)
+      throw makeChatUnavailableError();
     const target = await admittedSendTarget(chatId, options);
-    return getSendActions().sendSharedAttachment(target.routeAnchor, attachment, target.options);
+    if (attemptGeneration !== generation)
+      throw makeChatUnavailableError();
+    return send(target);
   };
+  const sendDurableAttachment = (chatId, attachment, options = {}) => withReadyAttachmentTarget(chatId, options, (target) => getSendActions().sendAttachment(target.routeAnchor, attachment, target.options));
+  const sendDurableSharedAttachment = (chatId, attachment, options = {}) => withReadyAttachmentTarget(chatId, options, (target) => getSendActions().sendSharedAttachment(target.routeAnchor, attachment, target.options));
   const stagePendingMessage = (launchId, local) => {
-    if (!pendingLaunch || pendingLaunch.id !== launchId)
+    const launch = launchForChat(launchId);
+    if (!launch || launch.id !== launchId)
       throw makeChatUnavailableError();
-    const { id, profiles, settings, chat } = pendingLaunch;
+    const { id, profiles, settings, chat } = launch;
+    const canonicalId = resolvePendingChatId(launchId);
+    if (getOwnerChat(canonicalId)) {
+      const { chatDraft: _draft, ...content } = local;
+      setLocalByChat((current) => addLocalMessage(current, canonicalId, content));
+      return;
+    }
     const chatDraft = { id, canonicalChatId: id, profiles, settings, chat };
     setLocalByChat((current) => addLocalMessage(current, launchId, { ...local, chatDraft }));
   };
@@ -29322,6 +29500,8 @@ function createChatSessionPending({
       const canonical = targetId !== launchId ? current.get(targetId) || [] : [];
       const writerIds = new Set(canonical.map((message) => message.cid));
       const staged = (current.get(launchId) || []).filter((message) => !writerIds.has(message.cid));
+      if (!canonical.length && !staged.length)
+        return current;
       next.set(targetId, [...canonical, ...staged].map((message) => {
         const { chatDraft, ...content } = message;
         return {
@@ -29337,14 +29517,22 @@ function createChatSessionPending({
     if (getOwnerChat(canonicalId) && pendingLaunch?.id === launchId)
       setSelectedChat(canonicalId);
   };
-  const retirePeer = (peerChatPK) => {
-    const launch = pendingLaunch;
-    if (!launch?.chat?.members?.some((member) => member?.chatPK === peerChatPK))
+  const dropChat = (chatId) => {
+    const launch = launchForChat(chatId);
+    if (!launch || launch.id !== chatId && launch.canonicalChatId !== chatId)
       return false;
     beginSelection();
     getRouteOwner().releaseOpenOperation?.(launch.id);
-    pendingLaunch = null;
-    pendingOperations.delete(launch.id);
+    if (pendingLaunch?.id === launch.id)
+      pendingLaunch = null;
+    cancelOperation(launch.id);
+    setLocalByChat((current) => {
+      if (!current.has(launch.id))
+        return current;
+      const next = new Map(current);
+      next.delete(launch.id);
+      return next;
+    });
     if (getSelectedChatId() === launch.id || getSelectedChatId() === launch.canonicalChatId) {
       setSelectedChat(null);
     } else {
@@ -29352,25 +29540,74 @@ function createChatSessionPending({
     }
     return true;
   };
+  const retirePeer = (peerChatPK) => pendingLaunch?.chat?.members?.some((member) => member?.chatPK === peerChatPK) ? dropChat(pendingLaunch.id) : false;
+  const discardChat = async (chatId) => {
+    const state = operationForChat(chatId);
+    if (!state?.dispatched)
+      return { discarded: dropChat(chatId), chat: null };
+    state.discarding = true;
+    if (pendingLaunch?.id === state.launch.id)
+      pendingLaunch = null;
+    if ([state.launch.id, state.canonicalChatId].includes(getSelectedChatId()))
+      setSelectedChat(null);
+    else
+      publish();
+    state.retirementTarget ||= getOwnerChat(state.canonicalChatId) || null;
+    if (state.retirementTarget)
+      retireMaterializedChat(state.canonicalChatId);
+    const attemptGeneration = generation;
+    await state.promise.catch(() => null);
+    if (attemptGeneration !== generation)
+      throw makeChatUnavailableError();
+    if (!state.retirementTarget) {
+      if (!getOwnerChat(state.canonicalChatId))
+        await ensureChat(state.canonicalChatId);
+      state.retirementTarget = getOwnerChat(state.canonicalChatId) || null;
+    }
+    if (attemptGeneration !== generation || !state.retirementTarget)
+      throw makeChatUnavailableError();
+    retireMaterializedChat(state.canonicalChatId);
+    return { discarded: true, chat: state.retirementTarget };
+  };
   const materialize = (launchId, wakeMessageId, sendInitial) => {
     const launch = pendingLaunch;
     if (!launch || launch.id !== launchId || pendingOperations.has(launchId))
       throw makeChatUnavailableError();
     const attemptGeneration = generation;
+    const state = { active: true, promise: null, launch, canonicalChatId: launchId };
+    pendingOperations.set(launchId, state);
+    const assertCurrent = () => {
+      if (attemptGeneration !== generation || !state.active)
+        throw makeChatUnavailableError();
+    };
     const expiresAt = Date.now() + CHAT_SEND_CONNECTION_WAIT_MS;
     let canonicalId = launchId;
     const operation = (async () => {
       await waitForSend(launchId, { expiresAt });
-      if (attemptGeneration !== generation)
-        throw makeChatUnavailableError();
+      assertCurrent();
       let initialResult = null;
       const lifecycle = {
         wakeMessageId,
+        assertCurrent,
+        onCreateDispatched: (chatId) => {
+          assertCurrent();
+          state.dispatched = true;
+          state.canonicalChatId = chatId;
+          state.launch = { ...state.launch, canonicalChatId: chatId };
+        },
         onStateReady: (chatId) => {
+          assertCurrent();
           canonicalId = chatId;
+          state.canonicalChatId = chatId;
+          state.launch = { ...state.launch, canonicalChatId: chatId };
           adoptOpenedChatId(chatId, launchId);
+          if (state.discarding) {
+            state.retirementTarget = getOwnerChat(chatId);
+            retireMaterializedChat(chatId);
+          }
         },
         onOwnerReady: async (chatId, _opened, context) => {
+          assertCurrent();
           canonicalId = chatId;
           initialResult = await sendInitial(chatId, { ...context, expiresAt });
           return initialResult;
@@ -29385,18 +29622,20 @@ function createChatSessionPending({
           canonicalId = resolvedChatId;
           initialResult = await sendInitial(resolvedChatId, { created: false, expiresAt });
         } else {
-          canonicalId = await getRouteOwner().createGroupChat(launch.profiles, launch.settings, {
+          canonicalId = await getRouteOwner().materializeGroupChat(launch.profiles, launch.settings, {
             ...lifecycle,
-            chatId: launchId
+            chatId: launch.canonicalChatId,
+            lineage: launch.chat.lineage
           });
         }
       }
       if (attemptGeneration !== generation)
         throw makeChatUnavailableError();
-      settleMaterialization(launchId, canonicalId);
+      if (state.active)
+        settleMaterialization(launchId, canonicalId);
       return { ...initialResult || {}, chatId: canonicalId };
     })().catch((error) => {
-      if (attemptGeneration === generation)
+      if (attemptGeneration === generation && state.active)
         settleMaterialization(launchId, canonicalId, true);
       throw error;
     });
@@ -29407,10 +29646,74 @@ function createChatSessionPending({
     ...context?.expiresAt ? { expiresAt: context.expiresAt } : {},
     ...context?.created === true ? { deliverRecipients: false, ownerImmediate: true } : {}
   });
+  const runChatMutation = (chatId, mutate, { initialProfiles } = {}) => {
+    const launch = launchForChat(chatId);
+    const canonicalId = resolvePendingChatId(chatId);
+    const active = launch && pendingOperations.get(launch.id);
+    if (active?.discarding)
+      throw makeChatUnavailableError();
+    if (!active && getOwnerChat(canonicalId))
+      return mutate(canonicalId, { created: false });
+    if (!launch || getIdentity().chatBanned)
+      throw makeChatUnavailableError();
+    const attemptGeneration = generation;
+    const perform = async (id, context) => {
+      if (attemptGeneration !== generation)
+        throw makeChatUnavailableError();
+      const value = await mutate(id, context);
+      if (attemptGeneration !== generation)
+        throw makeChatUnavailableError();
+      const ownerEntry = getOwnerChat(id)?.ownEntry;
+      if (!ownerEntry)
+        throw makeChatUnavailableError();
+      return { value, ownerEntry };
+    };
+    if (active) {
+      return track(launch.id, active.promise.then(async (result) => {
+        if (!active.active)
+          throw makeChatUnavailableError();
+        const id = result?.chatId || launch.canonicalChatId;
+        return { ...await perform(id, { created: false }), chatId: id };
+      })).then((result) => result.value);
+    }
+    pendingLaunch = launch;
+    if (initialProfiles) {
+      if (launch.chat.lineage === "self")
+        throw new Error("self chat membership is fixed");
+      const profiles = initialProfiles(launch.profiles);
+      if (profiles === launch.profiles)
+        return Promise.resolve({ unchanged: true });
+      const members = profiles.map(profileMember);
+      chatCapabilities(members.length + 1);
+      const self = memberFromChatIdentity(transitionIdentity());
+      if (members.some((member) => member.chatPK === self.chatPK))
+        throw new Error("current user is already a chat member");
+      const lineage = launch.chat.lineage === "group" || members.length !== 1 ? "group" : launch.chat.lineage;
+      pendingLaunch = {
+        ...launch,
+        canonicalChatId: lineage === "group" && launch.chat.lineage !== "group" ? randomChatId() : launch.canonicalChatId,
+        profiles: profiles.map((profile, index) => pendingProfile(profile, members[index])),
+        chat: {
+          ...launch.chat,
+          lineage,
+          peerChatPK: lineage === "direct" ? members[0]?.chatPK || null : null,
+          members: [self, ...members],
+          memberCount: members.length + 1,
+          memberChatPKs: [self.chatPK, ...members.map((member) => member.chatPK)],
+          memberUids: [self.uid, ...members.map((member) => member.uid)]
+        }
+      };
+      publish();
+    }
+    return materialize(launch.id, "", (id, context) => perform(id, {
+      ...context,
+      ...initialSendOptions({}, context)
+    })).then((result) => result.value);
+  };
   const sendPendingMessage = (launchId, message, options = {}) => {
     const { chatPK } = getIdentity();
-    const launch = pendingLaunch;
-    const previousOperation = pendingOperations.get(launchId);
+    const launch = launchForChat(launchId);
+    const previousOperation = pendingOperations.get(launchId)?.promise;
     if (!launch || launch.id !== launchId)
       throw makeChatUnavailableError();
     const routeAnchor = launch.chat?.members?.find((member) => member.chatPK !== chatPK)?.chatPK || chatPK;
@@ -29429,8 +29732,8 @@ function createChatSessionPending({
   };
   const sendPendingAttachment = (launchId, attachment, options = {}) => {
     const { chatPK } = getIdentity();
-    const launch = pendingLaunch;
-    const previousOperation = pendingOperations.get(launchId);
+    const launch = launchForChat(launchId);
+    const previousOperation = pendingOperations.get(launchId)?.promise;
     if (!launch || launch.id !== launchId)
       throw makeChatUnavailableError();
     const routeAnchor = launch.chat?.members?.find((member) => member.chatPK !== chatPK)?.chatPK || chatPK;
@@ -29445,8 +29748,8 @@ function createChatSessionPending({
   };
   const sendPendingSharedAttachment = (launchId, attachment, options = {}) => {
     const { chatPK } = getIdentity();
-    const launch = pendingLaunch;
-    const previousOperation = pendingOperations.get(launchId);
+    const launch = launchForChat(launchId);
+    const previousOperation = pendingOperations.get(launchId)?.promise;
     if (!launch || launch.id !== launchId)
       throw makeChatUnavailableError();
     const routeAnchor = launch.chat?.members?.find((member) => member.chatPK !== chatPK)?.chatPK || chatPK;
@@ -29459,6 +29762,12 @@ function createChatSessionPending({
     return track(launchId, previousOperation.then((result) => sendDurableSharedAttachment(result?.chatId || launchId, queuedAttachment, options)));
   };
   const sendChatMessage = (chatId, message, options = {}) => {
+    const operation = operationForChat(chatId);
+    if (operation?.discarding)
+      throw makeChatUnavailableError();
+    if (operation)
+      return sendPendingMessage(operation.launch.id, message, options);
+    chatId = resolvePendingChatId(chatId);
     if (!getOwnerChat(chatId)) {
       if (!pendingLaunch)
         pendingLaunch = storedLaunch(chatId);
@@ -29469,9 +29778,10 @@ function createChatSessionPending({
     return sendDurableMessage(chatId, message, options);
   };
   const retryMessage = (chatId, cid) => {
+    chatId = resolvePendingChatId(chatId);
     const attemptGeneration = generation;
     const launch = pendingLaunch && (pendingLaunch.id === chatId || pendingLaunch.canonicalChatId === chatId) ? pendingLaunch : storedLaunch(chatId);
-    const failed = getLocalByChat().get(launch?.id || chatId)?.find((message) => message.cid === cid && message.failed);
+    const failed = getLocalByChat().get(chatId)?.find((message) => message.cid === cid && message.failed);
     if (!failed)
       return false;
     if (launch && !getOwnerChat(chatId)) {
@@ -29508,8 +29818,24 @@ function createChatSessionPending({
     getSendActions().discardLocalMessage(chatId, cid);
     return true;
   };
-  const sendChatAttachment = (chatId, attachment, options = {}) => pendingLaunch?.id === chatId && !getOwnerChat(chatId) ? sendPendingAttachment(chatId, attachment, options) : sendDurableAttachment(chatId, attachment, options);
-  const sendChatSharedAttachment = (chatId, attachment, options = {}) => pendingLaunch?.id === chatId && !getOwnerChat(chatId) ? sendPendingSharedAttachment(chatId, attachment, options) : sendDurableSharedAttachment(chatId, attachment, options);
+  const sendChatAttachment = (chatId, attachment, options = {}) => {
+    const operation = operationForChat(chatId);
+    if (operation?.discarding)
+      throw makeChatUnavailableError();
+    if (operation)
+      return sendPendingAttachment(operation.launch.id, attachment, options);
+    chatId = resolvePendingChatId(chatId);
+    return pendingLaunch?.id === chatId && !getOwnerChat(chatId) ? sendPendingAttachment(chatId, attachment, options) : sendDurableAttachment(chatId, attachment, options);
+  };
+  const sendChatSharedAttachment = (chatId, attachment, options = {}) => {
+    const operation = operationForChat(chatId);
+    if (operation?.discarding)
+      throw makeChatUnavailableError();
+    if (operation)
+      return sendPendingSharedAttachment(operation.launch.id, attachment, options);
+    chatId = resolvePendingChatId(chatId);
+    return pendingLaunch?.id === chatId && !getOwnerChat(chatId) ? sendPendingSharedAttachment(chatId, attachment, options) : sendDurableSharedAttachment(chatId, attachment, options);
+  };
   const sendDirectAttachment = async (profile, attachment, options = {}) => sendChatAttachment(await getRouteOwner().openDirectChat(profile), attachment, options);
   const sendMaterializedDirect = async (profile, payload, options, send) => {
     const queuedPayload = { ...payload, cid: makeSendCid(payload) };
@@ -29556,6 +29882,10 @@ function createChatSessionPending({
     return settleNormalizedTargets(normalizedTargets, (target) => sendPickerTarget(target, (chatId) => sendChatSharedAttachment(chatId, attachment), (profile) => sendPickerDirectSharedAttachment(profile, attachment)));
   };
   return {
+    directAdmissionForPeer: admission.directAdmissionForPeer,
+    dropChat,
+    discardChat,
+    canStartDirectChat: admission.canStartDirectChat,
     adoptOpenedChatId,
     adoptResolved,
     beginPendingChat,
@@ -29563,8 +29893,11 @@ function createChatSessionPending({
     canSendToChat,
     isChatAdmitted,
     isPendingLaunchAdmitted,
-    isPendingChat: (chatId) => pendingLaunch?.id === chatId || !!storedLaunch(chatId),
+    isPendingChat: (chatId) => !!launchForChat(chatId),
     getPendingLaunch,
+    getActionChat: (chatId) => getOwnerChat(resolvePendingChatId(chatId)) || launchForChat(chatId)?.chat || null,
+    hasPendingChatOperation: (chatId) => !!operationForChat(chatId),
+    runChatMutation,
     openNewChat,
     retirePeer,
     reconcileAdmission: () => {
@@ -29574,7 +29907,7 @@ function createChatSessionPending({
       beginSelection();
       getRouteOwner().clearOpenOperations?.();
       pendingLaunch = null;
-      pendingOperations.delete(launch.id);
+      cancelOperation(launch.id);
       if (getSelectedChatId() === launch.id || getSelectedChatId() === launch.canonicalChatId) {
         setSelectedChat(null);
       } else {
@@ -29584,10 +29917,13 @@ function createChatSessionPending({
     },
     reset: () => {
       generation += 1;
+      admission.reset();
       beginSelection();
       if (pendingLaunch?.id)
         getRouteOwner().releaseOpenOperation?.(pendingLaunch.id);
       pendingLaunch = null;
+      for (const operation of pendingOperations.values())
+        operation.active = false;
       pendingOperations.clear();
     },
     selectChat: (chatId, { flushPrevious }) => {
@@ -29600,9 +29936,14 @@ function createChatSessionPending({
       const selectResolved = () => {
         if (!isSelectionCurrent(selection) || getIdentity().chatBanned)
           return false;
-        if (pendingLaunch && chatId !== pendingLaunch.id && !pendingOperations.has(pendingLaunch.id)) {
+        if (pendingLaunch && chatId !== pendingLaunch.id) {
+          if (chatId === pendingLaunch.canonicalChatId) {
+            settleMaterialization(pendingLaunch.id, chatId);
+          }
           getRouteOwner().releaseOpenOperation?.(pendingLaunch.id);
           pendingLaunch = null;
+          if (getSelectedChatId() === chatId)
+            publish();
         }
         const previousChatId = getSelectedChatId();
         if (previousChatId && previousChatId !== chatId)
@@ -30119,7 +30460,6 @@ function createChatDelete({
     for (const chatId of chatIds || []) {
       if (!chatId)
         continue;
-      dropCachedChat(localCache, chatId);
       closeMessageBatchRef.current?.(chatId);
       if (localForRender.has(chatId)) {
         if (!localChanged)
@@ -30151,6 +30491,7 @@ function createChatDelete({
         keepSelectedDeletedChatIdsRef.current.delete(chatId);
       }
     }
+    dropCachedChats(localCache, ids);
     clearDeletedChatState(ids);
     renderVisibleChats();
     setSelectedChat((current) => current && ids.includes(current) && !options?.keepSelected ? null : current);
@@ -30208,9 +30549,7 @@ function createChatDelete({
   const dropChat = (chatId) => {
     if (!chatId)
       return;
-    clearDeletedChatState([chatId]);
     listActionsRef.current?.removeOwner?.(chatId, { warm: false });
-    setSelectedChat((current) => current === chatId ? null : current);
   };
   const dropLeftChat = (chatId) => {
     if (!chatId)
@@ -31576,8 +31915,6 @@ async function setOwnChatNotificationMode(cloud, identity, entryId, entry, value
     if (!current?.current || current.retirement)
       throw makeChatUnavailableError();
     const manifest = current.current.manifest;
-    if (manifest.lineage !== "group")
-      throw new Error("group chat required");
     const requestedMode = cleanText(value);
     const notificationMode = normalizeChatNotificationMode(requestedMode, manifest);
     if (notificationMode !== requestedMode) {
@@ -31637,20 +31974,20 @@ function createChatSessionNotifications({
       throw makeChatUnavailableError();
     }
   };
-  const requireOwnerChat = (chatId, operation, { group = false } = {}) => {
+  const requireOwnerChat = (chatId, operation) => {
     assertCurrent(operation);
     const chat = getOwnerChat(chatId);
-    if (operation.identity.chatBanned || canWriteChat(chatId) !== true || group && chat?.lineage !== "group" || !chat.ownEntry || chat.ownEntry.retirement || !chat.entryId) {
+    if (operation.identity.chatBanned || canWriteChat(chatId) !== true || !chat?.ownEntry || chat.ownEntry.retirement || !chat.entryId) {
       throw makeChatUnavailableError();
     }
     return chat;
   };
   const setChatNotificationMode = async (chatId, mode) => {
     const operation = operationContext();
-    requireOwnerChat(chatId, operation, { group: true });
+    requireOwnerChat(chatId, operation);
     const releaseMutation = await operation.mutationGate.acquireExclusive(chatId);
     try {
-      const chat = requireOwnerChat(chatId, operation, { group: true });
+      const chat = requireOwnerChat(chatId, operation);
       const committed = await writeMode(cloud, operation.identity, chat.entryId, chat.ownEntry, mode);
       assertCurrent(operation);
       const projected = projectOwnChatEntry(committed, chat.entryId, operation.identity.chatPK, chat.ts);
@@ -32036,7 +32373,7 @@ function createChatSession({
     const owner = getOwnerChat(chatId);
     if (owner)
       return !isChatMembershipRemoved(owner);
-    return pendingOwner?.getPendingLaunch()?.id === chatId;
+    return pendingOwner?.isPendingChat(chatId) === true;
   };
   const requireOnline = () => {
     if (!online)
@@ -32051,10 +32388,6 @@ function createChatSession({
     if (chatId && !isMutableChat(chatId))
       throw makeChatUnavailableError();
   };
-  const gateChatMutation = (fn) => (chatId, ...rest) => {
-    requireMutableChat(chatId);
-    return fn(chatId, ...rest);
-  };
   const gateAdmittedChatMutation = (fn) => (chatId, ...rest) => {
     requireMutableChat(chatId);
     return Promise.resolve(pendingOwner.assertChatAdmission(chatId)).then(() => fn(chatId, ...rest));
@@ -32256,7 +32589,8 @@ function createChatSession({
     getPeerProfile,
     resolvePeerProfile,
     setLocalByChat,
-    getLocalByChat: () => localByChatRef.current
+    getLocalByChat: () => localByChatRef.current,
+    retireMaterializedChat: (chatId) => actionOwner.deleteActions.beginRetirement(chatId)
   });
   launchOwner = createChatSessionLaunches({
     cloud,
@@ -32296,29 +32630,79 @@ function createChatSession({
   const openDirectChat = (...args) => launchOwner.openDirectChat(...args);
   const openNotesChat = (...args) => launchOwner.openNotesChat(...args);
   const openNewChat = (...args) => pendingOwner.openNewChat(...args);
-  const directAdmissionForPeer2 = (profile) => directAdmissionForPeer(chatPrivateKey, chatPK, profile, chatAdmission);
-  const canStartDirectChat2 = (profile) => canStartDirectChat(chatPrivateKey, chatPK, profile, chatAdmission);
+  const { directAdmissionForPeer: directAdmissionForPeer2, canStartDirectChat } = pendingOwner;
   const canInviteToGroup2 = (profile) => canInviteToGroup(profile, chatAdmission);
   const createGroupChat2 = (...args) => launchOwner.createGroupChat(...args);
   const selectLocalChat = (...args) => launchOwner.selectLocalChat(...args);
-  const addChatMembers = async (chatId, profiles) => {
+  const mutateMaterializedChat = (chatId, mutate, options) => {
     requireMutableChat(chatId);
-    await pendingOwner.assertChatAdmission(chatId);
-    return membershipOwner.addChatMembers(chatId, profiles);
+    return pendingOwner.runChatMutation(chatId, async (id, context) => {
+      await pendingOwner.assertChatAdmission(id);
+      return mutate(id, context);
+    }, options);
+  };
+  const addChatMembers = (chatId, profiles) => {
+    const additions = Array.isArray(profiles) ? profiles : [profiles];
+    additions.forEach(membershipOwner.profileMember);
+    return mutateMaterializedChat(chatId, (id, context) => context.created ? { entry: getOwnerChat(id).ownEntry } : membershipOwner.addChatMembers(id, additions), {
+      initialProfiles: (current) => {
+        const next = new Map(current.map((profile) => [profile.chatPK, profile]));
+        for (const profile of additions)
+          next.set(profile.chatPK, profile);
+        return next.size === current.length ? current : [...next.values()];
+      }
+    });
   };
-  const kickChatMember = async (chatId, memberChatPK) => {
-    requireMutableChat(chatId);
-    await pendingOwner.assertChatAdmission(chatId);
-    return membershipOwner.kickChatMember(chatId, memberChatPK);
+  const kickChatMember = (chatId, memberChatPK) => {
+    const target = cleanText(memberChatPK);
+    if (!target)
+      throw new Error("chat member required");
+    if (target === chatPK && pendingOwner.isPendingChat(chatId)) {
+      return deleteChat(chatId);
+    }
+    return mutateMaterializedChat(chatId, (id, context) => context.created ? { entry: getOwnerChat(id).ownEntry } : membershipOwner.kickChatMember(id, target), {
+      initialProfiles: (current) => current.some((profile) => profile.chatPK === target) ? current.filter((profile) => profile.chatPK !== target) : current
+    });
   };
   const leaveChat = (chatId) => {
+    if (pendingOwner.isPendingChat(chatId)) {
+      return deleteChat(chatId);
+    }
     requireMutableChat(chatId);
     return membershipOwner.leaveChat(chatId);
   };
   const leaveOwnedChat = (...args) => membershipOwner.leaveOwnedChat(...args);
-  const updateChatSettings2 = gateAdmittedChatMutation((...args) => settingsOwner.updateChatSettings(...args));
-  const updateChatAvatar = gateAdmittedChatMutation((...args) => settingsOwner.updateChatAvatar(...args));
-  const setChatNotificationMode = gateAdmittedChatMutation((...args) => notificationsOwner.setChatNotificationMode(...args));
+  const sharedSettingsChat = (chatId) => {
+    const chat = pendingOwner.getActionChat(chatId);
+    if (chat?.lineage === "self")
+      throw new Error("self chat identity follows your profile");
+    return chat;
+  };
+  const updateChatSettings2 = async (chatId, settings) => {
+    const chat = sharedSettingsChat(chatId);
+    const requested = normalizeChatSettingsInput({ ...chat?.settings, ...settings });
+    const changes = ["title", "avatarRef", "retention"].filter((key) => Object.prototype.hasOwnProperty.call(settings, key));
+    const patch = Object.fromEntries(changes.map((key) => [key, requested[key]]));
+    if (chat && !pendingOwner.hasPendingChatOperation(chatId) && changes.every((key) => chat.settings?.[key] === requested[key])) {
+      return Promise.resolve({ unchanged: true });
+    }
+    return mutateMaterializedChat(chatId, (id) => settingsOwner.updateChatSettings(id, patch));
+  };
+  const updateChatAvatar = async (chatId, data) => {
+    assertChatAvatarBytes(data);
+    const chat = sharedSettingsChat(chatId);
+    if (chat?.lineage !== "group")
+      throw new Error("group chat required");
+    return mutateMaterializedChat(chatId, (id) => settingsOwner.updateChatAvatar(id, data));
+  };
+  const setChatNotificationMode = async (chatId, mode) => {
+    const chat = pendingOwner.getActionChat(chatId);
+    if (chat && normalizeChatNotificationMode(mode, chat) !== mode)
+      throw new Error("all notifications are unavailable in large groups");
+    if (chat && !pendingOwner.hasPendingChatOperation(chatId) && (chat.notificationMode || defaultChatNotificationMode(chat)) === mode)
+      return mode;
+    return mutateMaterializedChat(chatId, (id) => notificationsOwner.setChatNotificationMode(id, mode));
+  };
   const updateMessage = async (chatId, original, changes) => {
     if (chatBanned)
       throw makeChatUnavailableError();
@@ -32472,7 +32856,27 @@ function createChatSession({
   };
   const dropChat = (...args) => actionOwner.deleteActions.dropChat(...args);
   const dropUnavailableChat = (...args) => actionOwner.deleteActions.dropUnavailableChat(...args);
-  const deleteChat = gateOnlineMutation((...args) => actionOwner.deleteActions.deleteChat(...args));
+  const deleteChat = async (value, options) => {
+    const inputs = Array.isArray(value) ? value : [value];
+    const durable = [];
+    let discarded = 0;
+    for (const input of inputs) {
+      const id = cleanText(typeof input === "string" ? input : input?.chatId || input?.id);
+      if (pendingOwner.hasPendingChatOperation(id) || !getOwnerChat(id) && pendingOwner.isPendingChat(id)) {
+        const result = await pendingOwner.discardChat(id);
+        if (result.chat)
+          durable.push(result.chat);
+        else if (result.discarded)
+          discarded += 1;
+      } else
+        durable.push(input);
+    }
+    if (!durable.length)
+      return Array.isArray(value) ? discarded : discarded > 0;
+    requireOnline();
+    const deleted = await actionOwner.deleteActions.deleteChat(Array.isArray(value) ? durable : durable[0], options);
+    return Array.isArray(value) ? discarded + Number(deleted) : deleted;
+  };
   const purgePeerChats = async (affected, operation) => {
     const identity = operation.identity;
     for (const chat of affected) {
@@ -32577,14 +32981,14 @@ function createChatSession({
   const sendPendingChatMessage = (...args) => pendingOwner.sendPendingChatMessage(...args);
   const sendChatMessage = sendMessage;
   const sendDirectAttachment = gateOnlineMutation((...args) => pendingOwner.sendDirectAttachment(...args));
-  const sendChatAttachment = gateChatMutation((...args) => pendingOwner.sendChatAttachment(...args));
+  const sendChatAttachment = gateOnlineMutation((...args) => pendingOwner.sendChatAttachment(...args));
   const retryMessage = async (...args) => {
     const result = await pendingOwner.retryMessage(...args);
     if (online)
       drainMembershipOutbox();
     return result;
   };
-  const sendAttachment = gateChatMutation((...args) => pendingOwner.sendChatAttachment(...args));
+  const sendAttachment = gateOnlineMutation((...args) => pendingOwner.sendChatAttachment(...args));
   const sendChatImage = (chatId, image, options = {}) => sendChatAttachment(chatId, { ...image, type: image?.type || "img" }, options);
   const sendAttachmentMany = gateOnlineMutation((...args) => pendingOwner.sendAttachmentMany(...args));
   const sendImageMany = (targets, image, options = {}) => sendAttachmentMany(targets, { ...image, type: image?.type || "img" }, options);
@@ -32642,7 +33046,11 @@ function createChatSession({
     });
     return state;
   };
-  const setChatTtl = gateAdmittedChatMutation((...args) => settingsOwner.setChatTtl(...args));
+  const setChatTtl = async (chatId, retention) => {
+    const next = cleanChatRetention(retention);
+    await updateChatSettings2(chatId, { retention: next });
+    return next;
+  };
   const makeMessagePermanent = gateAdmittedChatMutation((...args) => actionOwner.saveActions.makeMessagePermanent(...args));
   const makeMessageTemporary = gateAdmittedChatMutation((...args) => actionOwner.saveActions.makeMessageTemporary(...args));
   const readMessageFile = (...args) => actionOwner.saveActions.readMessageFile(...args);
@@ -32745,6 +33153,17 @@ function createChatSession({
     chatsRef,
     reconcileMessageBatches: (...args) => messageBatchOwner.reconcileChats(...args),
     warmChats: (...args) => messageBatchOwner.warm(...args),
+    onOwnerRemoved: (chatIds) => {
+      for (const chatId of chatIds)
+        pendingOwner.dropChat(chatId);
+      actionOwner.deleteActions.clearDeletedChatState(chatIds);
+      for (const chatId of chatIds) {
+        actionOwner.liveActions.closeChatActivity(chatId);
+        historyOwner.clear(chatId);
+        messageBatchOwner.routeMemory.dropChat(chatId);
+        routeMemoryScopes.delete(chatId);
+      }
+    },
     onTransition: stageCommittedMembershipMessage,
     onRemoved: (removedChatId, _epochVersion, retiredEntry) => {
       const applied = chatListOwner.applyMembershipRemoval(removedChatId, retiredEntry);
@@ -32801,7 +33220,7 @@ function createChatSession({
     openNotesChat,
     openNewChat,
     directAdmissionForPeer: directAdmissionForPeer2,
-    canStartDirectChat: canStartDirectChat2,
+    canStartDirectChat,
     canInviteToGroup: canInviteToGroup2,
     createGroupChat: createGroupChat2,
     addChatMembers,
@@ -33247,7 +33666,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
   let expiryTimer = null;
   let command = null;
   let authenticating = null;
-  let snapshot = Object.freeze({ visibility: null, ready: false, pending: false, error: null, ...UNKNOWN_PRESENCE });
+  let snapshot = Object.freeze({ visibility: null, ready: false, pending: false, pendingVisibility: null, error: null, ...UNKNOWN_PRESENCE });
   function topic() {
     return sources.uid ? derivePresenceTopic(realm2, sources.uid) : null;
   }
@@ -33255,7 +33674,13 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
     return Boolean(channel && challenge && policy && sources.enabled && !closed);
   }
   function publish(patch = {}) {
-    const next = { ...snapshot, ...patch, ready: isReady() };
+    const next = {
+      ...snapshot,
+      ...patch,
+      ready: isReady(),
+      pending: Boolean(command),
+      pendingVisibility: command?.policy.visibility ?? null
+    };
     if (Object.keys(next).every((key) => Object.is(next[key], snapshot[key])))
       return;
     snapshot = Object.freeze(next);
@@ -33311,7 +33736,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
     const pending = command;
     command = null;
     clearTimeout(pending.timer);
-    publish({ pending: false, error });
+    publish({ error });
     if (error)
       pending.reject(error);
     else
@@ -33551,12 +33976,14 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
       listener();
   }
   function update(next) {
-    const identityChanged = sources.uid !== next.uid || sources.identity?.publicKey !== next.identity?.publicKey;
+    const accountChanged = sources.uid !== next.uid;
+    const identityChanged = accountChanged || sources.identity?.publicKey !== next.identity?.publicKey;
     if (identityChanged) {
       stop();
       policy = null;
       records.clear();
-      peers.clear();
+      if (accountChanged)
+        peers.clear();
       publish({ visibility: null, error: null, ...UNKNOWN_PRESENCE });
     }
     sources = next;
@@ -33586,7 +34013,7 @@ function createPresence({ cloud, diag = null, now = Date.now } = {}) {
         reject,
         timer: setTimeout(() => finishCommand(new Error("could not confirm activity setting; reconnect to check")), COMMAND_TIMEOUT_MS)
       };
-      publish({ pending: true, error: null });
+      publish({ error: null });
       if (!channel.send(presenceShard(topic()), { type: "policy", expectedRevision: policy.revision, policy: nextPolicy })) {
         finishCommand(new Error("could not update activity while offline"));
       }
@@ -36938,6 +37365,7 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
   let profilesLoading = false;
   let hydratedCacheKey = "";
   let avatarHydrateKey = "";
+  let avatarPublishSession = null;
   let profilesReady = false;
   let blockedPeersReady = false;
   let discoveredPeerUids = new Set;
@@ -37348,12 +37776,21 @@ function createPeerList({ peerApi, presence, diag, onMissingPeers }) {
     const session = lifecycle;
     const startedAt = Date.now();
     const requested = walletPKs.length + chatPeerPKs.length;
-    hydrateCachedAvatars(walletPKs, chatPeerPKs).then((changed) => {
+    hydrateCachedAvatars(walletPKs, chatPeerPKs, () => {
+      if (!isCurrent(session) || avatarPublishSession === session)
+        return;
+      avatarPublishSession = session;
+      queueMicrotask(() => {
+        if (avatarPublishSession !== session)
+          return;
+        avatarPublishSession = null;
+        if (isCurrent(session))
+          rebuild({ base: true, persist: false });
+      });
+    }).then((changed) => {
       if (!isCurrent(session))
         return;
       markDiag(diag, "peers.avatars.hydrate", { requested, changed, elapsedMs: Date.now() - startedAt });
-      if (changed)
-        rebuild({ base: true });
     }).catch((error) => {
       if (!isCurrent(session))
         return;
@@ -37933,7 +38370,7 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
   function uniqueLookupKeys(keys) {
     return uniqueValues(keys);
   }
-  async function hydrateCachedAvatars(walletPKs, chatPKs) {
+  async function hydrateCachedAvatars(walletPKs, chatPKs, onHydrated) {
     if (typeof avatarCache?.read !== "function")
       return false;
     const profiles = new Map;
@@ -37952,21 +38389,18 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
       queue(key, "chat");
     if (!profiles.size)
       return false;
-    const cached = await Promise.all(Array.from(profiles.values()).map(async ({ uid, version }) => ({
-      avatar: await readCachedAvatar(uid, version),
-      uid,
-      version
-    })));
     let changed = false;
-    for (const entry of cached) {
-      if (!entry.avatar)
-        continue;
-      const current = profileCache.get(entry.uid);
-      if (!current || current.avatarVersion !== entry.version || current.avatar === entry.avatar)
-        continue;
-      storeProfile({ ...current, avatar: entry.avatar });
+    await Promise.all(Array.from(profiles.values()).map(async ({ uid, version }) => {
+      const avatar = await readCachedAvatar(uid, version);
+      if (!avatar)
+        return;
+      const current = profileCache.get(uid);
+      if (!current || current.avatarVersion !== version || current.avatar === avatar)
+        return;
+      storeProfile({ ...current, avatar });
       changed = true;
-    }
+      onHydrated?.();
+    }));
     return changed;
   }
   function needsAvatarResolve(profile) {
@@ -40556,6 +40990,7 @@ function createPayment({
       throw new Error("bitcoin payment must be reviewed before sending");
     }
     const payment = paymentInput?.state === PAYMENT_STATE_PREPARED ? normalizePreparedPayment(paymentInput, wallet, network) : await preparePayment(paymentInput);
+    assertReady();
     const startedAt = Date.now();
     const diagKind = payment.kind;
     markDiag(diag, "wallet.payment.start", { kind: diagKind });