@glyphteck/veyl 0.70.0 → 0.71.0

package/dist/cli.js

@@ -1009,6 +1009,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 copyBytes2(bytes) {
   return Uint8Array.from(abytes2(bytes));
 }
@@ -4726,7 +4736,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)
@@ -5170,7 +5180,7 @@ var init_aes = __esm(() => {
         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");
         }
@@ -5857,7 +5867,7 @@ function sameText(left, right) {
 }
 
 // ../../core/config.js
-var MS_PER_SECOND = 1000, MINUTE_MS, HOUR_MS, DAY_MS, KIB_BYTES = 1024, MIB_BYTES, SATS_PER_BITCOIN = 100000000n, USERNAME_MAX_CHARS = 12, PASSWORD_MIN_CHARS = 15, PASSWORD_MAX_CHARS = 64, PASSWORD_MAX_BYTES, ACCOUNT_CONNECTION_SLOW_MS, ACCOUNT_CONNECTION_UNAVAILABLE_MS, ACCOUNT_CONNECTION_RETRY_MIN_MS, ACCOUNT_CONNECTION_RETRY_MAX_MS, AUTOLOCK_MIN_MINUTES = 1, AUTOLOCK_MAX_MINUTES = 60, BTC_PRICE_FALLBACK = 80000, CHAT_MESSAGE_EDIT_WINDOW_MS, CHAT_SEND_CONNECTION_WAIT_MS, LOCAL_CACHE_WRITE_DELAY_MS = 350, LOCAL_MEDIA_CACHE_MAX_BYTES, LOCAL_MEDIA_CACHE_MAX_ITEMS = 1000, LOCAL_MEDIA_ACCESS_TOUCH_MIN_MS, LOCAL_PROFILE_CACHE_MAX_ITEMS = 500, LOCAL_PROFILE_CACHE_MAX_AGE_MS, LOCAL_CHAT_CACHE_MAX_ITEMS = 1000, LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000, LOCAL_CHAT_MESSAGE_CACHE_WRITE_DELAY_MS = 2500, LOCAL_AVATAR_CACHE_MAX_BYTES, LOCAL_AVATAR_CACHE_MAX_AGE_MS, AVATAR_IMAGE_MAX_BYTES, AVATAR_IMAGE_QUALITY_ATTEMPTS, CHAT_AVATAR_IMAGE_MAX_BYTES, CHAT_AVATAR_REF_MAX_CHARS = 256, CHAT_MESSAGE_FILE_CACHE_MAX_BYTES, IDLE_CALLBACK_MIN_TIMEOUT_MS = 50, ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500, ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250, CHAT_UNSAVED_TTL_DAYS = 21, CHAT_UNSAVED_TTL_MS, CHAT_AFTER_SEEN_MS, CHAT_MEDIA_TTL_DAYS, CHAT_MEDIA_TTL_MS, CHAT_UPLOAD_MAX_BYTES, CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS, CHAT_MESSAGE_BATCH_SIZE = 40, CHAT_MESSAGE_QUERY_MAX_DOCS = 120, CHAT_MESSAGE_MUTATION_MAX_ITEMS = 256, CHAT_TTL_CLIENT_DELETE_GRACE_MS, CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500, CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250, CHAT_LIST_PAGE_SIZE = 20, CHAT_LIST_LIVE_COUNT, CHAT_INBOX_PING_PAGE_SIZE = 25, CHAT_INBOX_DISCOVERY_PARALLEL_CHATS, CHAT_INBOX_SETTLEMENT_PARALLEL_CHATS = 4, CHAT_INBOX_CURSOR_OVERLAP_MS, CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500, CHAT_LIST_SNAPSHOT_COALESCE_MS = 80, CHAT_LIST_COMPLETE_SYNC_DELAY_MS = 250, CHAT_LIST_LISTENER_RETRY_MS = 1000, CHAT_TOP_WARM_COUNT = 0, CHAT_EAGER_WARM_COUNT = 0, CHAT_WARM_DELAY_MS = 3000, CHAT_WARM_BATCH_SIZE, CHAT_MESSAGE_VIEW_CACHE_SIZE = 30, CHAT_MEDIA_WARM_MESSAGES_PER_CHAT, CHAT_MEDIA_WARM_START_DELAY_MS = 600, CHAT_MEDIA_WARM_STEP_DELAY_MS = 120, CHAT_MEDIA_WARM_TYPES, CHAT_MEDIA_WARM_MAX_BYTES = 0, CHAT_READ_WRITE_INTERVAL_MS, CHAT_READ_WRITE_MAX_WAIT_MS, CHAT_LIVE_PING_INTERVAL_MS, CHAT_LIVE_SWEEP_INTERVAL_MS, CHAT_LIVE_STALE_AFTER_MS, CHAT_LIVE_RECONNECT_MIN_MS = 250, CHAT_LIVE_RECONNECT_MAX_MS, CHAT_LIVE_TYPING_IDLE_MS, CHAT_LIVE_TYPING_RENEW_MS, CHAT_LIVE_COMPOSITION_HANDOFF_MS, CHAT_LIVE_READ_SEND_INTERVAL_MS = 120, CHAT_LIVE_READ_SEND_MAX_WAIT_MS = 500, CHAT_LIVE_READ_WRITE_INTERVAL_MS, CHAT_LIVE_READ_WRITE_MAX_WAIT_MS, CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12, CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS, CHAT_SETTINGS_BODY_MAX_BYTES, CHAT_TITLE_STATE_MAX_CHARS = 128, CHAT_MANIFEST_MAX_BYTES, CHAT_RECEIPT_MAX_MEMBERS = 32, CHAT_ORDINARY_DELIVERY_MAX_MEMBERS = 128, CHAT_MAX_MEMBERS = 256, CHAT_LARGE_GROUP_MENTION_MAX_TARGETS = 16, CHAT_MAX_TEXT_CHARS = 2048, CHAT_TITLE_INPUT_MAX_CHARS = 16, CHAT_MAX_REACTIONS, SEARCH_DEBOUNCE_MS = 300, SEARCH_USERNAME_LIMIT = 15, SEARCH_ROLE_LIMIT = 15, RECENT_PEER_REFRESH_LIMIT = 50, RECENT_PEER_REFRESH_DELAY_MS = 250, RECENT_PEER_REFRESH_THROTTLE_MS = 120, BAN_REFRESH_GRACE_MS = 50, REQUEST_MONEY_MAX_SATS, WALLET_TRANSFER_POLL_MS, WALLET_ACTIVE_TRANSFER_REFRESH_MS, WALLET_CACHE_HYDRATE_DELAY_MS = 0, WALLET_BOOT_REFRESH_DELAY_MS = 500, WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500, WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS, WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS, WALLET_BALANCE_EVENT_COALESCE_MS, WALLET_INCOMING_UPDATE_COALESCE_MS = 250, WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000, WALLET_CLAIM_PAGE_SIZE = 100, WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2, WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3, WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS, WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS, WALLET_SDK_BACKGROUND_QUIET_MS, WALLET_RECENT_TRANSFER_LIMIT = 100, WALLET_TRANSFER_PAGE_LIMIT = 100, WALLET_TRANSFER_FETCH_THROTTLE_MS = 150, WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS, WALLET_SENT_TRANSFER_REFRESH_DELAY_MS, WALLET_PENDING_TRANSFER_BOOT_GRACE_MS, WALLET_PENDING_TRANSFER_HOT_AGE_MS, WALLET_PENDING_TRANSFER_WARM_AGE_MS, WALLET_PENDING_TRANSFER_WARM_RETRY_MS, WALLET_PENDING_TRANSFER_STALE_RETRY_MS, WALLET_PENDING_TRANSFER_STUCK_RETRY_MS, WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS, WALLET_TRANSFER_CACHE_WRITE_DELAY_MS;
+var MS_PER_SECOND = 1000, MINUTE_MS, HOUR_MS, DAY_MS, KIB_BYTES = 1024, MIB_BYTES, SATS_PER_BITCOIN = 100000000n, USERNAME_MAX_CHARS = 12, PASSWORD_MIN_CHARS = 15, PASSWORD_MAX_CHARS = 64, PASSWORD_MAX_BYTES, ACCOUNT_CONNECTION_SLOW_MS, ACCOUNT_CONNECTION_UNAVAILABLE_MS, ACCOUNT_CONNECTION_RETRY_MIN_MS, ACCOUNT_CONNECTION_RETRY_MAX_MS, AUTOLOCK_MIN_MINUTES = 1, AUTOLOCK_MAX_MINUTES = 60, BTC_PRICE_FALLBACK = 80000, CHAT_MESSAGE_EDIT_WINDOW_MS, CHAT_SEND_CONNECTION_WAIT_MS, LOCAL_CACHE_WRITE_DELAY_MS = 350, LOCAL_MEDIA_CACHE_MAX_BYTES, LOCAL_MEDIA_CACHE_MAX_ITEMS = 1000, LOCAL_MEDIA_ACCESS_TOUCH_MIN_MS, LOCAL_PROFILE_CACHE_MAX_ITEMS = 500, LOCAL_PROFILE_CACHE_MAX_AGE_MS, LOCAL_CHAT_CACHE_MAX_ITEMS = 1000, LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000, LOCAL_CHAT_MESSAGE_CACHE_WRITE_DELAY_MS = 2500, LOCAL_AVATAR_CACHE_MAX_BYTES, LOCAL_AVATAR_CACHE_MAX_AGE_MS, AVATAR_IMAGE_MAX_BYTES, AVATAR_IMAGE_QUALITY_ATTEMPTS, CHAT_AVATAR_IMAGE_MAX_BYTES, CHAT_AVATAR_REF_MAX_CHARS = 256, CHAT_MESSAGE_FILE_CACHE_MAX_BYTES, IDLE_CALLBACK_MIN_TIMEOUT_MS = 50, ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500, ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250, CHAT_UNSAVED_TTL_DAYS = 21, CHAT_UNSAVED_TTL_MS, CHAT_AFTER_SEEN_MS, CHAT_MEDIA_TTL_DAYS, CHAT_MEDIA_TTL_MS, CHAT_UPLOAD_MAX_BYTES, CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS, CHAT_MESSAGE_BATCH_SIZE = 40, CHAT_MESSAGE_QUERY_MAX_DOCS = 120, CHAT_MESSAGE_MUTATION_MAX_ITEMS = 256, CHAT_TTL_CLIENT_DELETE_GRACE_MS, CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500, CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250, CHAT_LIST_PAGE_SIZE = 20, CHAT_ADMISSION_CACHE_PEERS = 1024, CHAT_LIST_LIVE_COUNT, CHAT_INBOX_PING_PAGE_SIZE = 25, CHAT_INBOX_DISCOVERY_PARALLEL_CHATS, CHAT_INBOX_SETTLEMENT_PARALLEL_CHATS = 4, CHAT_INBOX_CURSOR_OVERLAP_MS, CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500, CHAT_LIST_SNAPSHOT_COALESCE_MS = 80, CHAT_LIST_COMPLETE_SYNC_DELAY_MS = 250, CHAT_LIST_LISTENER_RETRY_MS = 1000, CHAT_TOP_WARM_COUNT = 0, CHAT_EAGER_WARM_COUNT = 0, CHAT_WARM_DELAY_MS = 3000, CHAT_WARM_BATCH_SIZE, CHAT_MESSAGE_VIEW_CACHE_SIZE = 30, CHAT_MEDIA_WARM_MESSAGES_PER_CHAT, CHAT_MEDIA_WARM_START_DELAY_MS = 600, CHAT_MEDIA_WARM_STEP_DELAY_MS = 120, CHAT_MEDIA_WARM_TYPES, CHAT_MEDIA_WARM_MAX_BYTES = 0, CHAT_READ_WRITE_INTERVAL_MS, CHAT_READ_WRITE_MAX_WAIT_MS, CHAT_LIVE_PING_INTERVAL_MS, CHAT_LIVE_SWEEP_INTERVAL_MS, CHAT_LIVE_STALE_AFTER_MS, CHAT_LIVE_RECONNECT_MIN_MS = 250, CHAT_LIVE_RECONNECT_MAX_MS, CHAT_LIVE_TYPING_IDLE_MS, CHAT_LIVE_TYPING_RENEW_MS, CHAT_LIVE_COMPOSITION_HANDOFF_MS, CHAT_LIVE_READ_SEND_INTERVAL_MS = 120, CHAT_LIVE_READ_SEND_MAX_WAIT_MS = 500, CHAT_LIVE_READ_WRITE_INTERVAL_MS, CHAT_LIVE_READ_WRITE_MAX_WAIT_MS, CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12, CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS, CHAT_SETTINGS_BODY_MAX_BYTES, CHAT_TITLE_STATE_MAX_CHARS = 128, CHAT_MANIFEST_MAX_BYTES, CHAT_RECEIPT_MAX_MEMBERS = 32, CHAT_ORDINARY_DELIVERY_MAX_MEMBERS = 128, CHAT_MAX_MEMBERS = 256, CHAT_LARGE_GROUP_MENTION_MAX_TARGETS = 16, CHAT_MAX_TEXT_CHARS = 2048, CHAT_TITLE_INPUT_MAX_CHARS = 16, CHAT_MAX_REACTIONS, SEARCH_DEBOUNCE_MS = 300, SEARCH_USERNAME_LIMIT = 15, SEARCH_ROLE_LIMIT = 15, RECENT_PEER_REFRESH_LIMIT = 50, RECENT_PEER_REFRESH_DELAY_MS = 250, RECENT_PEER_REFRESH_THROTTLE_MS = 120, BAN_REFRESH_GRACE_MS = 50, REQUEST_MONEY_MAX_SATS, WALLET_TRANSFER_POLL_MS, WALLET_ACTIVE_TRANSFER_REFRESH_MS, WALLET_CACHE_HYDRATE_DELAY_MS = 0, WALLET_BOOT_REFRESH_DELAY_MS = 500, WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500, WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS, WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS, WALLET_BALANCE_EVENT_COALESCE_MS, WALLET_INCOMING_UPDATE_COALESCE_MS = 250, WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000, WALLET_CLAIM_PAGE_SIZE = 100, WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2, WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3, WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS, WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS, WALLET_SDK_BACKGROUND_QUIET_MS, WALLET_RECENT_TRANSFER_LIMIT = 100, WALLET_TRANSFER_PAGE_LIMIT = 100, WALLET_TRANSFER_FETCH_THROTTLE_MS = 150, WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS, WALLET_SENT_TRANSFER_REFRESH_DELAY_MS, WALLET_PENDING_TRANSFER_BOOT_GRACE_MS, WALLET_PENDING_TRANSFER_HOT_AGE_MS, WALLET_PENDING_TRANSFER_WARM_AGE_MS, WALLET_PENDING_TRANSFER_WARM_RETRY_MS, WALLET_PENDING_TRANSFER_STALE_RETRY_MS, WALLET_PENDING_TRANSFER_STUCK_RETRY_MS, WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS, WALLET_TRANSFER_CACHE_WRITE_DELAY_MS;
 var init_config = __esm(() => {
   MINUTE_MS = 60 * MS_PER_SECOND;
   HOUR_MS = 60 * MINUTE_MS;
@@ -5998,9 +6008,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;
@@ -7110,7 +7123,7 @@ var xchacha20, ZEROS162, updatePadded = (h, msg) => {
       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");
       }
@@ -8850,35 +8863,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;
@@ -8939,6 +8985,8 @@ var CHAT_ADMISSION_VERSION = 1, CHAT_ADMISSION_GRANT_COUNT = 8, CHAT_ADMISSION_D
 var init_admission = __esm(() => {
   init_ed25519();
   init_sha2();
+  init_utils2();
+  init_config();
   init_core();
   init_kdf();
   init_manifest();
@@ -11143,6 +11191,29 @@ var init_transition = __esm(() => {
   TRANSITION_MEMBER_SCOPE = encoder.encode("veyl-chat-transition-member-v3");
 });
 
+// ../../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);
+}
+var init_capabilities = __esm(() => {
+  init_config();
+});
+
 // ../../core/chat/ttl.js
 function hasChatRetention(value) {
   const retention = cleanText(value);
@@ -11191,7 +11262,7 @@ function messageExpiryMs(retention, seenAt) {
   }
   return cleanChatRetention(retention) === CHAT_RETENTION_24H ? seenAt + AFTER_SEEN_MS : seenAt;
 }
-var CHAT_RETENTION_SEEN = "seen", CHAT_RETENTION_24H = "24h", CHAT_RETENTION_FOREVER = "forever", DEFAULT_CHAT_RETENTION, CHAT_RETENTION_VALUES, CHAT_PROTOCOL_RETENTION_VALUES, CHAT_RETENTION_LABELS, MESSAGE_STORAGE_TTL_MS, AFTER_SEEN_MS;
+var CHAT_RETENTION_SEEN = "seen", CHAT_RETENTION_24H = "24h", CHAT_RETENTION_FOREVER = "forever", DEFAULT_CHAT_RETENTION, CHAT_RETENTION_VALUES, CHAT_PROTOCOL_RETENTION_VALUES, CHAT_RETENTION_LABELS, CHAT_RETENTION_DESCRIPTIONS, MESSAGE_STORAGE_TTL_MS, AFTER_SEEN_MS;
 var init_ttl = __esm(() => {
   init_config();
   init_time();
@@ -11203,6 +11274,10 @@ var init_ttl = __esm(() => {
     [CHAT_RETENTION_SEEN]: "delete after seen",
     [CHAT_RETENTION_24H]: "keep for 24h"
   });
+  CHAT_RETENTION_DESCRIPTIONS = Object.freeze({
+    [CHAT_RETENTION_SEEN]: "messages now delete after being seen",
+    [CHAT_RETENTION_24H]: "messages now delete 24h after being seen"
+  });
   MESSAGE_STORAGE_TTL_MS = CHAT_UNSAVED_TTL_MS;
   AFTER_SEEN_MS = CHAT_AFTER_SEEN_MS;
 });
@@ -11844,6 +11919,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) {
@@ -12681,29 +12758,6 @@ var init_chatstate = __esm(() => {
   STATE_SIGN_SCOPE = encoder.encode("veyl-chat-member-state-v3-sign");
 });
 
-// ../../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);
-}
-var init_capabilities = __esm(() => {
-  init_config();
-});
-
 // ../../core/chat/memberstate.js
 function openStateEpoch(epochState, actor = null) {
   if (!epochState?.manifest || !epochState?.epochSecret)
@@ -13894,7 +13948,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;
     }
@@ -13907,7 +13962,7 @@ function sameReactions(a, b) {
   if (left.length !== right.length) {
     return false;
   }
-  return left.every((reaction, index) => reaction.user === right[index]?.user && reaction.emoji === right[index]?.emoji);
+  return left.every((reaction, index) => reaction.user === right[index]?.user && reaction.emoji === right[index]?.emoji && reaction.ts === right[index]?.ts);
 }
 function hasReactionControl(messages) {
   for (const msg of messages || []) {
@@ -13947,7 +14002,8 @@ function deriveMessageReactions(messages, chatPK, peerChatPK, memberChatPKs = nu
       byTarget.set(target, reactions);
     }
     if (hasText(msg.emoji)) {
-      reactions.set(user, { emoji: cleanReactionEmoji(msg.emoji), user });
+      const ts = timestampMs(getMessageOrderMs(msg), null);
+      reactions.set(user, { emoji: cleanReactionEmoji(msg.emoji), user, ...ts == null ? {} : { ts } });
     } else {
       reactions.delete(user);
     }
@@ -15076,7 +15132,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,
@@ -15085,6 +15141,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
   };
@@ -15301,7 +15359,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
     };
@@ -20021,12 +20079,6 @@ function dropCachedChats(cache, chatIds, currentPayload = null) {
     ...ids.map((chatId) => dropCachedMessageState(cache, chatId))
   ]));
 }
-function dropCachedChat(cache, chatId) {
-  if (!chatId) {
-    return;
-  }
-  dropCachedChats(cache, [chatId]);
-}
 var init_chats2 = __esm(() => {
   init_config();
   init_time();
@@ -24927,6 +24979,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) {
@@ -26531,6 +26594,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")) {
@@ -26540,6 +26606,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)
@@ -26776,17 +26863,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();
@@ -26913,6 +27013,7 @@ async function preparePreparedPing(cloud, uid, identity, prepared, options) {
       ping,
       uid
     });
+    assertInboxLease(options);
     return { opened, releaseMutation };
   } catch (error) {
     releaseMutation();
@@ -27367,10 +27468,11 @@ async function prepareInboxWork(context, prepared, processingOptions = {}) {
   const { blockedUids, cloud, identity, options, state, uid } = context;
   const { document: document2, opened } = prepared;
   let announcement = null;
+  let ping = null;
   try {
     const authenticated = await authenticateInboxPing(cloud, identity, document2, 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,
@@ -27387,9 +27489,11 @@ async function prepareInboxWork(context, prepared, processingOptions = {}) {
     if (ping.opened?.result === "request") {
       await hydrateOpenedChatRequest(ping.opened.context);
     }
+    assertInboxLease(options);
     announcement = announcePreparedWelcome(context, authenticated, ping, document2, prepared.startedAt);
     return { announcement, document: document2, 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" });
@@ -27517,6 +27621,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);
@@ -27561,9 +27667,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;
       }
@@ -27584,6 +27693,7 @@ function createInboxSettlementController(options = {}) {
       if (!job || job.settled)
         continue;
       if (!hasLease()) {
+        job.discard?.(job.prepared);
         finishJob(job, inboxLeaseError());
         continue;
       }
@@ -27619,6 +27729,7 @@ function createInboxSettlementController(options = {}) {
     const job = {
       chatId,
       deferred: inboxDeferred(),
+      discard: task.discard,
       lane,
       prepare: task.prepare,
       prepared: null,
@@ -27676,6 +27787,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);
@@ -27987,6 +28102,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);
@@ -28211,7 +28327,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 });
@@ -28722,15 +28839,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) => {
@@ -28870,21 +28987,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));
@@ -28960,6 +29089,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;
@@ -28996,7 +29127,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);
@@ -29006,15 +29136,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 = {}) => {
@@ -29371,7 +29498,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);
@@ -29382,6 +29509,7 @@ function createChatListListener({
       retry(error);
     }, {
       limitCount: CHAT_LIST_LIVE_COUNT,
+      getSourceRevision: index.getAuthorityRevision,
       onInboxAnnouncement: index.announceWelcome,
       onInboxRevoke: index.revokeAnnouncement,
       onInboxCommit: index.commitOwner,
@@ -31040,7 +31168,7 @@ function patchMessageFromCachedMessage(message, cached) {
   const patch = {};
   let changed = false;
   const cachedReactions = getMsgReactions(cached);
-  if (cachedReactions.length && !sameReactionProjection(message, cached)) {
+  if (cachedReactions.length && !sameReactions(message.reactions, cached.reactions)) {
     patch.reactions = cachedReactions;
     changed = true;
   }
@@ -31066,19 +31194,6 @@ function patchMessageFromCachedMessage(message, cached) {
   }
   return changed ? { ...message, ...patch } : message;
 }
-function sameReactionProjection(a, b) {
-  const left = getMsgReactions(a);
-  const right = getMsgReactions(b);
-  if (left.length !== right.length) {
-    return false;
-  }
-  for (let index = 0;index < left.length; index += 1) {
-    if (left[index].user !== right[index]?.user || left[index].emoji !== right[index]?.emoji) {
-      return false;
-    }
-  }
-  return true;
-}
 function patchMessagesFromCachedWindow(messages, cachedMessages) {
   if (!messages?.length || !cachedMessages?.length) {
     return messages || [];
@@ -31735,6 +31850,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);
@@ -31755,7 +31871,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,
@@ -31818,6 +31934,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);
@@ -31829,6 +31946,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,
@@ -32183,21 +32302,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) {
@@ -32205,9 +32326,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");
       }
@@ -32221,8 +32343,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);
@@ -32261,6 +32382,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");
@@ -32270,15 +32392,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);
@@ -32289,7 +32419,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);
@@ -32303,6 +32433,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);
@@ -32374,6 +32508,7 @@ function createChatSessionLaunches({
     getOpenOperation: (chatId) => directOpens.get(chatId)?.promise || null,
     getPeerChatId,
     materializeDirectChat,
+    materializeGroupChat,
     openDirectChat,
     openNotesChat,
     releaseOpenOperation: (chatId) => {
@@ -32501,16 +32636,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,
@@ -32518,23 +32658,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)
@@ -32546,6 +32696,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);
@@ -32641,7 +32797,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)
@@ -32774,18 +32930,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: profiles2, settings, chat } = pendingLaunch;
+    const { id, profiles: profiles2, 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: profiles2, settings, chat };
     setLocalByChat((current) => addLocalMessage(current, launchId, { ...local, chatDraft }));
   };
@@ -32797,6 +32964,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 {
@@ -32812,14 +32981,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 {
@@ -32827,25 +33004,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;
@@ -32860,18 +33086,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;
     });
@@ -32882,10 +33110,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 profiles2 = initialProfiles(launch.profiles);
+      if (profiles2 === launch.profiles)
+        return Promise.resolve({ unchanged: true });
+      const members = profiles2.map(profileMember);
+      chatCapabilities(members.length + 1);
+      const self2 = memberFromChatIdentity(transitionIdentity());
+      if (members.some((member) => member.chatPK === self2.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: profiles2.map((profile, index) => pendingProfile(profile, members[index])),
+        chat: {
+          ...launch.chat,
+          lineage,
+          peerChatPK: lineage === "direct" ? members[0]?.chatPK || null : null,
+          members: [self2, ...members],
+          memberCount: members.length + 1,
+          memberChatPKs: [self2.chatPK, ...members.map((member) => member.chatPK)],
+          memberUids: [self2.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;
@@ -32904,8 +33196,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;
@@ -32920,8 +33212,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;
@@ -32934,6 +33226,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);
@@ -32944,9 +33242,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)) {
@@ -32983,8 +33282,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) };
@@ -33031,6 +33346,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,
@@ -33038,8 +33357,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: () => {
@@ -33049,7 +33371,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 {
@@ -33059,10 +33381,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 }) => {
@@ -33075,9 +33400,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)
@@ -33132,6 +33462,7 @@ var init_sessionpending = __esm(() => {
   init_messages();
   init_state();
   init_targets();
+  init_capabilities();
 });
 
 // ../../core/chat/sessionmembership.js
@@ -33626,7 +33957,6 @@ function createChatDelete({
     for (const chatId of chatIds || []) {
       if (!chatId)
         continue;
-      dropCachedChat(localCache, chatId);
       closeMessageBatchRef.current?.(chatId);
       if (localForRender.has(chatId)) {
         if (!localChanged)
@@ -33658,6 +33988,7 @@ function createChatDelete({
         keepSelectedDeletedChatIdsRef.current.delete(chatId);
       }
     }
+    dropCachedChats(localCache, ids);
     clearDeletedChatState(ids);
     renderVisibleChats();
     setSelectedChat((current) => current && ids.includes(current) && !options?.keepSelected ? null : current);
@@ -33715,9 +34046,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)
@@ -35138,8 +35467,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) {
@@ -35199,20 +35526,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);
@@ -35605,7 +35932,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)
@@ -35620,10 +35947,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));
@@ -35825,7 +36148,8 @@ function createChatSession({
     getPeerProfile,
     resolvePeerProfile,
     setLocalByChat,
-    getLocalByChat: () => localByChatRef.current
+    getLocalByChat: () => localByChatRef.current,
+    retireMaterializedChat: (chatId) => actionOwner.deleteActions.beginRetirement(chatId)
   });
   launchOwner = createChatSessionLaunches({
     cloud,
@@ -35865,29 +36189,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, profiles2) => {
+  const mutateMaterializedChat = (chatId, mutate, options) => {
     requireMutableChat(chatId);
-    await pendingOwner.assertChatAdmission(chatId);
-    return membershipOwner.addChatMembers(chatId, profiles2);
+    return pendingOwner.runChatMutation(chatId, async (id, context) => {
+      await pendingOwner.assertChatAdmission(id);
+      return mutate(id, context);
+    }, options);
   };
-  const kickChatMember = async (chatId, memberChatPK) => {
-    requireMutableChat(chatId);
-    await pendingOwner.assertChatAdmission(chatId);
-    return membershipOwner.kickChatMember(chatId, memberChatPK);
+  const addChatMembers = (chatId, profiles2) => {
+    const additions = Array.isArray(profiles2) ? profiles2 : [profiles2];
+    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 = (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();
@@ -36041,7 +36415,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) {
@@ -36146,14 +36540,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);
@@ -36211,7 +36605,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);
@@ -36314,6 +36712,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);
@@ -36370,7 +36779,7 @@ function createChatSession({
     openNotesChat,
     openNewChat,
     directAdmissionForPeer: directAdmissionForPeer2,
-    canStartDirectChat: canStartDirectChat2,
+    canStartDirectChat,
     canInviteToGroup: canInviteToGroup2,
     createGroupChat: createGroupChat2,
     addChatMembers,
@@ -36664,6 +37073,10 @@ var init_session3 = __esm(() => {
   init_sessionsources();
   init_entry();
   init_admission();
+  init_avatar2();
+  init_settings2();
+  init_ttl();
+  init_notifications();
   init_write();
   DEFAULT_READ_WRITE_INTERVAL_MS = CHAT_READ_WRITE_INTERVAL_MS;
   EMPTY_LOCAL_MESSAGES = Object.freeze([]);
@@ -36846,7 +37259,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;
   }
@@ -36854,7 +37267,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);
@@ -36910,7 +37329,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
@@ -37150,12 +37569,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;
@@ -37185,7 +37606,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"));
       }
@@ -40971,6 +41392,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;
@@ -41381,12 +41803,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;
@@ -41990,7 +42421,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 profiles2 = new Map;
@@ -42009,21 +42440,18 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
       queue(key, "chat");
     if (!profiles2.size)
       return false;
-    const cached = await Promise.all(Array.from(profiles2.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(profiles2.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) {
@@ -44693,6 +45121,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 });
@@ -53577,20 +54006,7 @@ function sameMessageList(a, b) {
   for (let i = 0;i < a.length; i += 1) {
     const left = a[i];
     const right = b[i];
-    if (getMessageKey(left) !== getMessageKey(right) || getMessageOrderMs(left) !== getMessageOrderMs(right) || hasMessageTtl(left) !== hasMessageTtl(right) || timestampKey(left?.ttl ?? null) !== timestampKey(right?.ttl ?? null) || !sameMessageReactions(left, right)) {
-      return false;
-    }
-  }
-  return true;
-}
-function sameMessageReactions(a, b) {
-  const left = getMsgReactions(a);
-  const right = getMsgReactions(b);
-  if (left.length !== right.length) {
-    return false;
-  }
-  for (let index2 = 0;index2 < left.length; index2 += 1) {
-    if (left[index2].user !== right[index2]?.user || left[index2].emoji !== right[index2]?.emoji) {
+    if (getMessageKey(left) !== getMessageKey(right) || getMessageOrderMs(left) !== getMessageOrderMs(right) || hasMessageTtl(left) !== hasMessageTtl(right) || timestampKey(left?.ttl ?? null) !== timestampKey(right?.ttl ?? null) || !sameReactions(left?.reactions, right?.reactions)) {
       return false;
     }
   }
@@ -54009,7 +54425,7 @@ function cacheMessageSignature(message) {
   if (!message)
     return "";
   const hasTtl = hasMessageTtl(message);
-  const reactions = getMsgReactions(message).map((reaction) => `${reaction.user}:${reaction.emoji}`).join(",");
+  const reactions = getMsgReactions(message).map((reaction) => `${reaction.user}:${reaction.emoji}:${reaction.ts ?? ""}`).join(",");
   return [
     cacheKeySignature(messageKeys(message)),
     getMessageOrderMs(message) || 0,
@@ -60625,7 +61041,7 @@ var package_default;
 var init_package2 = __esm(() => {
   package_default = {
     name: "veyl",
-    version: "0.70.0",
+    version: "0.71.0",
     packageManager: "bun@1.4.0",
     private: true,
     license: "UNLICENSED",
@@ -79010,7 +79426,7 @@ function ensureBytes(title, hex3, expectedLength) {
     throw new Error(title + " of length " + expectedLength + " expected, got " + len);
   return res;
 }
-function equalBytes2(a, b) {
+function equalBytes3(a, b) {
   if (a.length !== b.length)
     return false;
   let diff = 0;
@@ -109821,7 +110237,7 @@ var init_legacy = __esm(() => {
 });
 
 // ../../node_modules/.bun/micro-packed@0.7.3/node_modules/micro-packed/lib/esm/index.js
-function equalBytes3(a, b) {
+function equalBytes4(a, b) {
   if (a.length !== b.length)
     return false;
   for (let i = 0;i < a.length; i++)
@@ -109996,7 +110412,7 @@ class _Reader {
       const leftBytes = this.data.length - idx;
       if (leftBytes < needle.length)
         return;
-      if (equalBytes3(needle, this.data.subarray(idx, idx + needle.length)))
+      if (equalBytes4(needle, this.data.subarray(idx, idx + needle.length)))
         return idx;
     }
     return;
@@ -110348,7 +110764,7 @@ function magic(inner, constant, check = true) {
     encodeStream: (w, _value) => inner.encodeStream(w, constant),
     decodeStream: (r) => {
       const value = inner.decodeStream(r);
-      if (check && typeof value !== "object" && value !== constant || isBytes6(constant) && !equalBytes3(constant, value)) {
+      if (check && typeof value !== "object" && value !== constant || isBytes6(constant) && !equalBytes4(constant, value)) {
         throw r.err(`magic: invalid value: ${value} !== ${constant}`);
       }
       return;
@@ -110455,7 +110871,7 @@ function array(len, inner) {
               if (len.length > _w.pos - startPos)
                 return;
               const data = _w.finish(false).subarray(startPos, _w.pos);
-              if (equalBytes3(data.subarray(0, len.length), len))
+              if (equalBytes4(data.subarray(0, len.length), len))
                 throw _w.err(`array: inner element encoding same as separator. elm=${elm} data=${data}`);
             }
           });
@@ -110475,7 +110891,7 @@ function array(len, inner) {
           }
         } else if (isBytes6(len)) {
           for (let i = 0;; i++) {
-            if (equalBytes3(r.bytes(len.length, true), len)) {
+            if (equalBytes4(r.bytes(len.length, true), len)) {
               r.bytes(len.length);
               break;
             }
@@ -110688,7 +111104,7 @@ var EMPTY2, NULL, createView4 = (arr) => new DataView(arr.buffer, arr.byteOffset
     decodeStream: (r) => {
       let hasFlag = r.leftBytes >= flagValue.length;
       if (hasFlag) {
-        hasFlag = equalBytes3(r.bytes(flagValue.length, true), flagValue);
+        hasFlag = equalBytes4(r.bytes(flagValue.length, true), flagValue);
         if (hasFlag)
           r.bytes(flagValue.length);
       }
@@ -110706,7 +111122,7 @@ var init_esm2 = __esm(() => {
   EMPTY2 = /* @__PURE__ */ new Uint8Array;
   NULL = /* @__PURE__ */ new Uint8Array([0]);
   utils2 = {
-    equalBytes: equalBytes3,
+    equalBytes: equalBytes4,
     isBytes: isBytes6,
     isCoder,
     checkBounds,
@@ -110948,7 +111364,7 @@ function compareBytes(a, b) {
       return Math.sign(a[i] - b[i]);
   return Math.sign(a.length - b.length);
 }
-var Point, CURVE_ORDER, isBytes7, concatBytes7, equalBytes4, hash160 = (msg) => ripemd160(sha2562(msg)), sha256x2 = (...msgs) => sha2562(sha2562(concatBytes7(...msgs))), randomPrivateKeyBytes, pubSchnorr, pubECDSA, hasLowR = (sig) => sig.r < CURVE_ORDER / 2n, signSchnorr, tagSchnorr, PubT, TAPROOT_UNSPENDABLE_KEY, NETWORK, TEST_NETWORK;
+var Point, CURVE_ORDER, isBytes7, concatBytes7, equalBytes5, hash160 = (msg) => ripemd160(sha2562(msg)), sha256x2 = (...msgs) => sha2562(sha2562(concatBytes7(...msgs))), randomPrivateKeyBytes, pubSchnorr, pubECDSA, hasLowR = (sig) => sig.r < CURVE_ORDER / 2n, signSchnorr, tagSchnorr, PubT, TAPROOT_UNSPENDABLE_KEY, NETWORK, TEST_NETWORK;
 var init_utils6 = __esm(() => {
   init_secp256k1();
   init_legacy();
@@ -110958,7 +111374,7 @@ var init_utils6 = __esm(() => {
   CURVE_ORDER = secp256k1.CURVE.n;
   isBytes7 = utils2.isBytes;
   concatBytes7 = utils2.concatBytes;
-  equalBytes4 = utils2.equalBytes;
+  equalBytes5 = utils2.equalBytes;
   randomPrivateKeyBytes = schnorr.utils.randomPrivateKey;
   pubSchnorr = schnorr.getPublicKey;
   pubECDSA = secp256k1.getPublicKey;
@@ -111477,7 +111893,7 @@ function mergeKeyMap(psbtEnum, val, cur, allowedFields, allowUnknown) {
     } else if (typeof res[k] === "string") {
       res[k] = vC.decode(hex3.decode(res[k]));
     } else if (cannotChange && k in val && cur && cur[k] !== undefined) {
-      if (!equalBytes4(vC.encode(val[k]), vC.encode(cur[k])))
+      if (!equalBytes5(vC.encode(val[k]), vC.encode(cur[k])))
         throw new Error(`Cannot change signed field=${k}`);
     }
   }
@@ -111676,7 +112092,7 @@ function isValidPubkey(pub, type) {
   }
 }
 function checkWSH(s, witnessScript) {
-  if (!equalBytes4(s.hash, sha2562(witnessScript)))
+  if (!equalBytes5(s.hash, sha2562(witnessScript)))
     throw new Error("checkScript: wsh wrong witnessScript hash");
   const w = OutScript.decode(witnessScript);
   if (w.type === "tr" || w.type === "tr_ns" || w.type === "tr_ms")
@@ -111690,7 +112106,7 @@ function checkScript(script, redeemScript, witnessScript) {
     if (s.type === "tr_ns" || s.type === "tr_ms" || s.type === "ms" || s.type == "pk")
       throw new Error(`checkScript: non-wrapped ${s.type}`);
     if (s.type === "sh" && redeemScript) {
-      if (!equalBytes4(s.hash, hash160(redeemScript)))
+      if (!equalBytes5(s.hash, hash160(redeemScript)))
         throw new Error("checkScript: sh wrong redeemScript hash");
       const r = OutScript.decode(redeemScript);
       if (r.type === "tr" || r.type === "tr_ns" || r.type === "tr_ms")
@@ -111727,9 +112143,9 @@ function checkTaprootScript(script, internalPubKey, allowUnknownOutputs = false,
   const outms = out;
   if (!allowUnknownOutputs && outms.pubkeys) {
     for (const p of outms.pubkeys) {
-      if (equalBytes4(p, TAPROOT_UNSPENDABLE_KEY))
+      if (equalBytes5(p, TAPROOT_UNSPENDABLE_KEY))
         throw new Error("Unspendable taproot key in leaf script");
-      if (equalBytes4(p, internalPubKey)) {
+      if (equalBytes5(p, internalPubKey)) {
         throw new Error("Using P2TR with leaf script with same key as internal key is not supported");
       }
     }
@@ -111780,7 +112196,7 @@ function taprootHashTree(tree, internalPubKey, allowUnknownOutputs = false, cust
     tree = tree[0];
   if (!Array.isArray(tree)) {
     const { leafVersion: version, script: leafScript } = tree;
-    if (tree.tapLeafScript || tree.tapMerkleRoot && !equalBytes4(tree.tapMerkleRoot, EMPTY2))
+    if (tree.tapLeafScript || tree.tapMerkleRoot && !equalBytes5(tree.tapMerkleRoot, EMPTY2))
       throw new Error("P2TR: tapRoot leafScript cannot have tree");
     const script = typeof leafScript === "string" ? hex3.decode(leafScript) : leafScript;
     if (!isBytes7(script))
@@ -112159,7 +112575,7 @@ function cloneDeep(obj) {
   throw new Error(`cloneDeep: unknown type=${obj} (${typeof obj})`);
 }
 function getTaprootKeys(privKey, pubKey, internalKey, merkleRoot = EMPTY2) {
-  if (equalBytes4(internalKey, pubKey)) {
+  if (equalBytes5(internalKey, pubKey)) {
     privKey = taprootTweakPrivKey(privKey, merkleRoot);
     pubKey = pubSchnorr(privKey);
   }
@@ -112255,7 +112671,7 @@ function validateInput(i) {
     if (i.index > last)
       throw new Error(`validateInput: index(${i.index}) not in nonWitnessUtxo`);
     const prevOut = i.nonWitnessUtxo.outputs[i.index];
-    if (i.witnessUtxo && (!equalBytes4(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount))
+    if (i.witnessUtxo && (!equalBytes5(i.witnessUtxo.script, prevOut.script) || i.witnessUtxo.amount !== prevOut.amount))
       throw new Error("validateInput: witnessUtxo different from nonWitnessUtxo");
     if (i.txid) {
       const outputs = i.nonWitnessUtxo.outputs;
@@ -112811,7 +113227,7 @@ class Transaction {
         let s = privateKey;
         for (const i of path)
           s = s.deriveChild(i);
-        if (!equalBytes4(s.publicKey, pubKey))
+        if (!equalBytes5(s.publicKey, pubKey))
           throw new Error("bip32Derivation: wrong pubKey");
         if (!s.privateKey)
           throw new Error("bip32Derivation: no privateKey");
@@ -112848,7 +113264,7 @@ class Transaction {
       if (input.tapInternalKey) {
         const { pubKey, privKey } = getTaprootKeys(privateKey, schnorrPub, input.tapInternalKey, merkleRoot);
         const [taprootPubKey, _] = taprootTweakPubkey(input.tapInternalKey, merkleRoot);
-        if (equalBytes4(taprootPubKey, pubKey)) {
+        if (equalBytes5(taprootPubKey, pubKey)) {
           const hash = this.preimageWitnessV1(idx, prevOutScript, sighash, amount);
           const sig = concatBytes7(signSchnorr(hash, privKey, _auxRand), sighash !== SignatureHash.DEFAULT ? new Uint8Array([sighash]) : EMPTY2);
           this.updateInput(idx, { tapKeySig: sig }, true);
@@ -112862,7 +113278,7 @@ class Transaction {
           const scriptDecoded = Script.decode(script);
           const ver = _script[_script.length - 1];
           const hash = tapLeafHash(script, ver);
-          const pos = scriptDecoded.findIndex((i) => isBytes7(i) && equalBytes4(i, schnorrPub));
+          const pos = scriptDecoded.findIndex((i) => isBytes7(i) && equalBytes5(i, schnorrPub));
           if (pos === -1)
             continue;
           const msg = this.preimageWitnessV1(idx, prevOutScript, sighash, amount, undefined, script, ver);
@@ -112879,7 +113295,7 @@ class Transaction {
       let hasPubkey = false;
       const pubKeyHash = hash160(pubKey);
       for (const i of Script.decode(inputType.lastScript)) {
-        if (isBytes7(i) && (equalBytes4(i, pubKey) || equalBytes4(i, pubKeyHash)))
+        if (isBytes7(i) && (equalBytes5(i, pubKey) || equalBytes5(i, pubKeyHash)))
           hasPubkey = true;
       }
       if (!hasPubkey)
@@ -112929,14 +113345,14 @@ class Transaction {
           const ver = _script[_script.length - 1];
           const outScript = OutScript.decode(script);
           const hash = tapLeafHash(script, ver);
-          const scriptSig = input.tapScriptSig.filter((i) => equalBytes4(i[0].leafHash, hash));
+          const scriptSig = input.tapScriptSig.filter((i) => equalBytes5(i[0].leafHash, hash));
           let signatures = [];
           if (outScript.type === "tr_ms") {
             const m = outScript.m;
             const pubkeys = outScript.pubkeys;
             let added = 0;
             for (const pub of pubkeys) {
-              const sigIdx = scriptSig.findIndex((i) => equalBytes4(i[0].pubKey, pub));
+              const sigIdx = scriptSig.findIndex((i) => equalBytes5(i[0].pubKey, pub));
               if (added === m || sigIdx === -1) {
                 signatures.push(EMPTY2);
                 continue;
@@ -112948,7 +113364,7 @@ class Transaction {
               continue;
           } else if (outScript.type === "tr_ns") {
             for (const pub of outScript.pubkeys) {
-              const sigIdx = scriptSig.findIndex((i) => equalBytes4(i[0].pubKey, pub));
+              const sigIdx = scriptSig.findIndex((i) => equalBytes5(i[0].pubKey, pub));
               if (sigIdx === -1)
                 continue;
               signatures.push(scriptSig[sigIdx][1]);
@@ -112958,7 +113374,7 @@ class Transaction {
           } else if (outScript.type === "unknown" && this.opts.allowUnknownInputs) {
             const scriptDecoded = Script.decode(script);
             signatures = scriptSig.map(([{ pubKey }, signature]) => {
-              const pos = scriptDecoded.findIndex((i) => isBytes7(i) && equalBytes4(i, pubKey));
+              const pos = scriptDecoded.findIndex((i) => isBytes7(i) && equalBytes5(i, pubKey));
               if (pos === -1)
                 throw new Error("finalize/taproot: cannot find position of pubkey in script");
               return { signature, pos };
@@ -113006,7 +113422,7 @@ class Transaction {
       const pubkeys = inputType.last.pubkeys;
       let signatures = [];
       for (const pub of pubkeys) {
-        const sign3 = input.partialSig.find((s) => equalBytes4(pub, s[0]));
+        const sign3 = input.partialSig.find((s) => equalBytes5(pub, s[0]));
         if (!sign3)
           continue;
         signatures.push(sign3[1]);
@@ -113080,7 +113496,7 @@ class Transaction {
     }
     const thisUnsigned = this.global.unsignedTx ? RawOldTx.encode(this.global.unsignedTx) : EMPTY2;
     const otherUnsigned = other.global.unsignedTx ? RawOldTx.encode(other.global.unsignedTx) : EMPTY2;
-    if (!equalBytes4(thisUnsigned, otherUnsigned))
+    if (!equalBytes5(thisUnsigned, otherUnsigned))
       throw new Error(`Transaction/combine: different unsigned tx`);
     this.global = mergeKeyMap(PSBTGlobal, this.global, other.global, undefined, this.opts.allowUnknown);
     for (let i = 0;i < this.inputs.length; i++)
@@ -117913,7 +118329,7 @@ function validateCoopExitPayoutTransaction({ rawCoopExitTransaction, expectedCoo
     const output = tx.getOutput(i);
     if (!output?.script || output.amount === undefined)
       continue;
-    if (!equalBytes4(output.script, expectedScript))
+    if (!equalBytes5(output.script, expectedScript))
       continue;
     if (output.amount >= BigInt(expectedPayoutAmountSats))
       return;
@@ -118331,7 +118747,7 @@ function createSenderSpendTx({ htlcTx, network, hash, hashLockDestinationPubkey,
   const entry = p2.tapLeafScript.find(([, scriptWithVer]) => Buffer.compare(scriptWithVer.slice(0, -1), sequenceLockScript) === 0);
   const controlBlockBytes = TaprootControlBlock.encode(entry[0]);
   const seqLeafEntry = p2.tapLeafScript.find(([_, leaf]) => {
-    return equalBytes2(leaf.subarray(0, leaf.length - 1), sequenceLockScript);
+    return equalBytes3(leaf.subarray(0, leaf.length - 1), sequenceLockScript);
   });
   const sighash = senderSpendTx.preimageWitnessV1(0, [sequenceLockScript], SigHash.DEFAULT, [htlcAmount]);
   senderSpendTx.updateInput(0, {
@@ -118381,7 +118797,7 @@ function createReceiverSpendTx({ htlcTx, network, hash, hashLockDestinationPubke
     script: sequenceLockScript
   }]), network, true);
   const hashLeafEntry = p2.tapLeafScript.find(([_, leaf]) => {
-    return equalBytes2(leaf.subarray(0, leaf.length - 1), hashLockScript);
+    return equalBytes3(leaf.subarray(0, leaf.length - 1), hashLockScript);
   });
   spendTx.updateInput(0, {
     witnessUtxo: {
@@ -121131,7 +121547,7 @@ async function withRetry(operation, options = {}) {
 function scopeTransferLeavesToReceiver(transfer, receiverIdentityPublicKey) {
   if (transfer.receivers.length <= 1)
     return transfer;
-  const ownReceiver = transfer.receivers.find((receiver) => equalBytes2(receiver.identityPublicKey, receiverIdentityPublicKey));
+  const ownReceiver = transfer.receivers.find((receiver) => equalBytes3(receiver.identityPublicKey, receiverIdentityPublicKey));
   if (!ownReceiver?.id)
     throw new SparkValidationError("Cannot scope claim: wallet is not a receiver of this multi-receiver transfer");
   const ownLeaves = transfer.leaves.filter((leaf) => leaf.transferReceiverId === ownReceiver.id);
@@ -121146,7 +121562,7 @@ function isReceiverLegComplete(transfer, receiverIdentityPublicKey) {
   const wholeComplete = transfer.status === TransferStatus.TRANSFER_STATUS_COMPLETED;
   if (transfer.receivers.length <= 1)
     return wholeComplete;
-  const ownReceiver = transfer.receivers.find((receiver) => equalBytes2(receiver.identityPublicKey, receiverIdentityPublicKey));
+  const ownReceiver = transfer.receivers.find((receiver) => equalBytes3(receiver.identityPublicKey, receiverIdentityPublicKey));
   if (!ownReceiver)
     return false;
   return ownReceiver.status === TransferReceiverStatus.TRANSFER_RECEIVER_STATUS_COMPLETED || wholeComplete;
@@ -121892,7 +122308,7 @@ function isReceiverTransferStreamEvent(event2) {
 function findOutputPayingScript(tx, script) {
   for (let i = 0;i < tx.outputsLength; i++) {
     const outputScript = tx.getOutput(i).script;
-    if (outputScript && equalBytes2(outputScript, script))
+    if (outputScript && equalBytes3(outputScript, script))
       return i;
   }
 }
@@ -121923,7 +122339,7 @@ function resolveRecoverableOutput(leaf, nodes, network, recoveryTxid, outputInde
     const prevOut = tx.getOutput(outputIndex);
     if (prevOut.amount === undefined)
       continue;
-    if (!prevOut.script || !equalBytes2(prevOut.script, leafScript))
+    if (!prevOut.script || !equalBytes3(prevOut.script, leafScript))
       continue;
     return {
       txid,
@@ -123212,9 +123628,9 @@ var import_nice_grpc_common, import_light_bolt11_decoder, SparkFrostBase = class
   }
   signTransactionIndex(tx, index2, publicKey) {
     let privateKey;
-    if (equalBytes2(publicKey, this.identityKey?.publicKey ?? new Uint8Array))
+    if (equalBytes3(publicKey, this.identityKey?.publicKey ?? new Uint8Array))
       privateKey = this.identityKey?.privateKey;
-    else if (equalBytes2(publicKey, this.depositKey?.publicKey ?? new Uint8Array))
+    else if (equalBytes3(publicKey, this.depositKey?.publicKey ?? new Uint8Array))
       privateKey = this.depositKey?.privateKey;
     if (!privateKey)
       throw new SparkValidationError("Private key not found for public key", {
@@ -124055,7 +124471,7 @@ var import_nice_grpc_common, import_light_bolt11_decoder, SparkFrostBase = class
     return response.transfer;
   }
   compareTransfers(transfer1, transfer2) {
-    return transfer1.id === transfer2.id && equalBytes2(transfer1.senderIdentityPublicKey, transfer2.senderIdentityPublicKey) && transfer1.status === transfer2.status && transfer1.totalValue === transfer2.totalValue && transfer1.expiryTime?.getTime() === transfer2.expiryTime?.getTime() && transfer1.leaves.length === transfer2.leaves.length;
+    return transfer1.id === transfer2.id && equalBytes3(transfer1.senderIdentityPublicKey, transfer2.senderIdentityPublicKey) && transfer1.status === transfer2.status && transfer1.totalValue === transfer2.totalValue && transfer1.expiryTime?.getTime() === transfer2.expiryTime?.getTime() && transfer1.leaves.length === transfer2.leaves.length;
   }
 }, TransferService, CoopExitService, DENOMINATIONS, Swap = class {
   inLeaves;
@@ -124579,7 +124995,7 @@ var import_nice_grpc_common, import_light_bolt11_decoder, SparkFrostBase = class
     }
   }
   async handleTransferEvent(transfer) {
-    if (!this.identityPublicKey || !equalBytes2(transfer.senderIdentityPublicKey, this.identityPublicKey))
+    if (!this.identityPublicKey || !equalBytes3(transfer.senderIdentityPublicKey, this.identityPublicKey))
       return;
     const leafIds = transfer.leaves.flatMap((leaf) => leaf.leaf ? [leaf.leaf.id] : []);
     this.log("handleTransferEvent", `transfer=${transfer.id} type=${transfer.type} status=${transfer.status} leaves=[${leafIds.join(",")}]`);
@@ -125209,12 +125625,12 @@ var import_nice_grpc_common, import_light_bolt11_decoder, SparkFrostBase = class
     return pendingTransfer ? await this.transferService.claimTransfer(pendingTransfer) : [];
   }
   verifyKey(pubkey1, pubkey2, verifyingKey) {
-    return equalBytes2(addPublicKeys(pubkey1, pubkey2), verifyingKey);
+    return equalBytes3(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
   isLeafConsistent(leaf, opLeaf) {
     if (!opLeaf)
       return false;
-    return leaf.status === opLeaf.status && !!leaf.signingKeyshare && !!opLeaf.signingKeyshare && equalBytes2(leaf.signingKeyshare.publicKey, opLeaf.signingKeyshare.publicKey) && equalBytes2(leaf.nodeTx, opLeaf.nodeTx);
+    return leaf.status === opLeaf.status && !!leaf.signingKeyshare && !!opLeaf.signingKeyshare && equalBytes3(leaf.signingKeyshare.publicKey, opLeaf.signingKeyshare.publicKey) && equalBytes3(leaf.nodeTx, opLeaf.nodeTx);
   }
   restoreLocalLockedToAvailable(leafIds) {
     let changed = false;
@@ -134357,7 +134773,7 @@ var init_spark_wallet_CIYOesd9 = __esm(() => {
           if (traceId)
             this.logEvent(`handleStreamEvent: Receiver transfer ${transfer.id} traceId=${traceId}`);
           const { senderIdentityPublicKey, receiverIdentityPublicKey } = transfer;
-          const isSelf = equalBytes2(senderIdentityPublicKey, receiverIdentityPublicKey);
+          const isSelf = equalBytes3(senderIdentityPublicKey, receiverIdentityPublicKey);
           this.logEvent(`handleStreamEvent: Receiver transfer: id=${transfer.id} type=${transfer.type} status=${transfer.status} totalValue=${transfer.totalValue} leaves=${transfer.leaves.length} selfTransfer=${isSelf}`);
           if (!isSelf) {
             const incomingLeaves = transfer.leaves.map((l) => l.leaf).filter((l) => !!l);
@@ -135340,7 +135756,7 @@ var init_spark_wallet_CIYOesd9 = __esm(() => {
       const network = this.config.getNetwork();
       const identityPublicKey = await this.config.signer.getIdentityPublicKey();
       const nodes = await this.leafManager.queryWatchtowerExitedNodes();
-      return nodes.filter((node) => node.refundTx.length > 0 && equalBytes2(node.ownerIdentityPublicKey, identityPublicKey)).map((leaf) => {
+      return nodes.filter((node) => node.refundTx.length > 0 && equalBytes3(node.ownerIdentityPublicKey, identityPublicKey)).map((leaf) => {
         const recoverable = resolveRecoverableOutput(leaf, nodes, network);
         return {
           leafId: leaf.id,
@@ -135754,7 +136170,7 @@ var init_spark_wallet_CIYOesd9 = __esm(() => {
         }
         const transfer = await this.transferService.sendTransferV3(allLeafKeyTweaks);
         const signerIdentityPublicKey = await this.config.signer.getIdentityPublicKey();
-        if (decodedReceivers.some((r) => equalBytes2(r.identityPublicKey, signerIdentityPublicKey))) {
+        if (decodedReceivers.some((r) => equalBytes3(r.identityPublicKey, signerIdentityPublicKey))) {
           const pending = await this.transferService.queryTransfer(transfer.id);
           if (pending)
             await this.claimTransfer({ transfer: pending });
@@ -135798,7 +136214,7 @@ var init_spark_wallet_CIYOesd9 = __esm(() => {
         return await Promise.all(jobs.map(async (job) => {
           try {
             const transfer = await this.transferService.sendTransferWithKeyTweaks(job.leafKeyTweaks, job.sparkInvoice, job.transferId);
-            if (equalBytes2(signerIdentityPublicKey, job.receiverIdentityPubkey)) {
+            if (equalBytes3(signerIdentityPublicKey, job.receiverIdentityPubkey)) {
               const pending = await this.transferService.queryTransfer(transfer.id);
               if (pending)
                 await this.claimTransfer({ transfer: pending });
@@ -136473,7 +136889,7 @@ var init_spark_wallet_CIYOesd9 = __esm(() => {
       if (!transfer)
         throw new Error("Failed to provide preimage");
       const receiverIdentityPublicKey = transfer.receiverIdentityPublicKey;
-      if (equalBytes2(receiverIdentityPublicKey, await this.config.signer.getIdentityPublicKey()))
+      if (equalBytes3(receiverIdentityPublicKey, await this.config.signer.getIdentityPublicKey()))
         await this.claimTransfer({
           transfer,
           emit: true
@@ -136513,7 +136929,7 @@ var init_spark_wallet_CIYOesd9 = __esm(() => {
         fee
       });
       this.config.signer.signTransactionIndex(spendTx, 0, await this.config.signer.getIdentityPublicKey());
-      const sig = spendTx.getInput(0).tapScriptSig.find(([ref2]) => equalBytes2(ref2.leafHash, leafHash))?.[1];
+      const sig = spendTx.getInput(0).tapScriptSig.find(([ref2]) => equalBytes3(ref2.leafHash, leafHash))?.[1];
       spendTx.updateInput(0, { finalScriptWitness: [
         sig,
         hexToBytes4(preimage),