@glyphteck/veyl 0.66.3 → 0.68.0

package/dist/account.js

@@ -5618,11 +5618,158 @@ function sameText(left, right) {
   return lowerText(left) === lowerText(right);
 }
 
+// ../../core/config.js
+var MS_PER_SECOND = 1000;
+var MINUTE_MS = 60 * MS_PER_SECOND;
+var HOUR_MS = 60 * MINUTE_MS;
+var DAY_MS = 24 * HOUR_MS;
+var KIB_BYTES = 1024;
+var MIB_BYTES = 1024 * 1024;
+var SATS_PER_BITCOIN = 100000000n;
+var USERNAME_MAX_CHARS = 12;
+var PASSWORD_MIN_CHARS = 15;
+var PASSWORD_MAX_CHARS = 64;
+var PASSWORD_MAX_BYTES = 4 * 1024;
+var LOCAL_MEDIA_CACHE_MAX_BYTES = 512 * MIB_BYTES;
+var LOCAL_PROFILE_CACHE_MAX_ITEMS = 500;
+var LOCAL_PROFILE_CACHE_MAX_AGE_MS = 30 * DAY_MS;
+var LOCAL_CHAT_CACHE_MAX_ITEMS = 1000;
+var LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000;
+var LOCAL_AVATAR_CACHE_MAX_BYTES = 128 * MIB_BYTES;
+var LOCAL_AVATAR_CACHE_MAX_AGE_MS = 30 * DAY_MS;
+var AVATAR_IMAGE_MAX_BYTES = 256 * KIB_BYTES;
+var AVATAR_IMAGE_QUALITY_ATTEMPTS = Object.freeze([0.92, 0.84, 0.76, 0.68]);
+var CHAT_AVATAR_IMAGE_MAX_BYTES = AVATAR_IMAGE_MAX_BYTES;
+var CHAT_AVATAR_REF_MAX_CHARS = 256;
+var CHAT_MESSAGE_FILE_CACHE_MAX_BYTES = 64 * MIB_BYTES;
+var IDLE_CALLBACK_MIN_TIMEOUT_MS = 50;
+var ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500;
+var ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250;
+var CHAT_UNSAVED_TTL_DAYS = 21;
+var CHAT_UNSAVED_TTL_MS = CHAT_UNSAVED_TTL_DAYS * DAY_MS;
+var CHAT_AFTER_SEEN_MS = DAY_MS;
+var CHAT_MEDIA_TTL_DAYS = CHAT_UNSAVED_TTL_DAYS;
+var CHAT_MEDIA_TTL_MS = CHAT_MEDIA_TTL_DAYS * DAY_MS;
+var CHAT_UPLOAD_MAX_BYTES = 64 * MIB_BYTES;
+var CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000;
+var CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000;
+var CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS = CHAT_AUDIO_TRANSCODE_BITRATE_BPS;
+var CHAT_MESSAGE_BATCH_SIZE = 40;
+var CHAT_MESSAGE_QUERY_MAX_DOCS = 120;
+var CHAT_MESSAGE_MUTATION_MAX_ITEMS = 256;
+var CHAT_TTL_CLIENT_DELETE_GRACE_MS = MINUTE_MS;
+var CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500;
+var CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250;
+var CHAT_LIST_PAGE_SIZE = 20;
+var CHAT_LIST_LIVE_COUNT = CHAT_LIST_PAGE_SIZE;
+var CHAT_INBOX_PING_PAGE_SIZE = 25;
+var CHAT_INBOX_DISCOVERY_PARALLEL_CHATS = CHAT_INBOX_PING_PAGE_SIZE;
+var CHAT_INBOX_SETTLEMENT_PARALLEL_CHATS = 4;
+var CHAT_INBOX_CURSOR_OVERLAP_MS = 5 * MS_PER_SECOND;
+var CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500;
+var CHAT_LIST_SNAPSHOT_COALESCE_MS = 80;
+var CHAT_LIST_COMPLETE_SYNC_DELAY_MS = 250;
+var CHAT_LIST_LISTENER_RETRY_MS = 1000;
+var CHAT_TOP_WARM_COUNT = 0;
+var CHAT_EAGER_WARM_COUNT = 0;
+var CHAT_WARM_DELAY_MS = 3000;
+var CHAT_WARM_BATCH_SIZE = CHAT_MESSAGE_BATCH_SIZE;
+var CHAT_MESSAGE_VIEW_CACHE_SIZE = 30;
+var CHAT_MEDIA_WARM_MESSAGES_PER_CHAT = CHAT_MESSAGE_BATCH_SIZE;
+var CHAT_MEDIA_WARM_START_DELAY_MS = 600;
+var CHAT_MEDIA_WARM_STEP_DELAY_MS = 120;
+var CHAT_MEDIA_WARM_TYPES = Object.freeze(["img", "gif", "mp4"]);
+var CHAT_MEDIA_WARM_MAX_BYTES = 0;
+var CHAT_READ_WRITE_INTERVAL_MS = 2 * MS_PER_SECOND;
+var CHAT_READ_WRITE_MAX_WAIT_MS = 8 * MS_PER_SECOND;
+var CHAT_LIVE_PING_INTERVAL_MS = 5 * MS_PER_SECOND;
+var CHAT_LIVE_SWEEP_INTERVAL_MS = 15 * MS_PER_SECOND;
+var CHAT_LIVE_STALE_AFTER_MS = 15 * MS_PER_SECOND;
+var CHAT_LIVE_RECONNECT_MAX_MS = 5 * MS_PER_SECOND;
+var CHAT_LIVE_TYPING_IDLE_MS = 8 * MS_PER_SECOND;
+var CHAT_LIVE_TYPING_RENEW_MS = 5 * MS_PER_SECOND;
+var CHAT_LIVE_COMPOSITION_HANDOFF_MS = 15 * MS_PER_SECOND;
+var CHAT_LIVE_READ_SEND_INTERVAL_MS = 120;
+var CHAT_LIVE_READ_SEND_MAX_WAIT_MS = 500;
+var CHAT_LIVE_READ_WRITE_INTERVAL_MS = 12 * MS_PER_SECOND;
+var CHAT_LIVE_READ_WRITE_MAX_WAIT_MS = 30 * MS_PER_SECOND;
+var CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12;
+var CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS = 10 * MS_PER_SECOND;
+var CHAT_SETTINGS_BODY_MAX_BYTES = 32 * KIB_BYTES;
+var CHAT_TITLE_STATE_MAX_CHARS = 128;
+var CHAT_MANIFEST_MAX_BYTES = 256 * KIB_BYTES;
+var CHAT_RECEIPT_MAX_MEMBERS = 32;
+var CHAT_ORDINARY_DELIVERY_MAX_MEMBERS = 128;
+var CHAT_MAX_MEMBERS = 256;
+var CHAT_LARGE_GROUP_MENTION_MAX_TARGETS = 16;
+var CHAT_MAX_TEXT_CHARS = 2048;
+var CHAT_TITLE_INPUT_MAX_CHARS = 16;
+var CHAT_MAX_REACTIONS = CHAT_MAX_MEMBERS;
+var SEARCH_DEBOUNCE_MS = 300;
+var RECENT_PEER_REFRESH_LIMIT = 50;
+var RECENT_PEER_REFRESH_DELAY_MS = 250;
+var RECENT_PEER_REFRESH_INTERVAL_MS = 5 * MINUTE_MS;
+var RECENT_PEER_REFRESH_THROTTLE_MS = 120;
+var BAN_REFRESH_GRACE_MS = 50;
+var REQUEST_MONEY_MAX_SATS = SATS_PER_BITCOIN * 100000n;
+var WALLET_TRANSFER_POLL_MS = 3 * MS_PER_SECOND;
+var WALLET_ACTIVE_TRANSFER_REFRESH_MS = MS_PER_SECOND;
+var WALLET_CACHE_HYDRATE_DELAY_MS = 0;
+var WALLET_BOOT_REFRESH_DELAY_MS = 500;
+var WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500;
+var WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS = 20 * MS_PER_SECOND;
+var WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS = MINUTE_MS;
+var WALLET_BALANCE_EVENT_COALESCE_MS = 2 * MS_PER_SECOND;
+var WALLET_INCOMING_UPDATE_COALESCE_MS = 250;
+var WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000;
+var WALLET_CLAIM_PAGE_SIZE = 100;
+var WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50;
+var WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2;
+var WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50;
+var WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS = 15 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2;
+var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3;
+var WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS = 4 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS = 15 * MS_PER_SECOND;
+var WALLET_SDK_BACKGROUND_QUIET_MS = MS_PER_SECOND;
+var WALLET_RECENT_TRANSFER_LIMIT = 100;
+var WALLET_TRANSFER_PAGE_LIMIT = 100;
+var WALLET_TRANSFER_FETCH_THROTTLE_MS = 150;
+var WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS = 3 * MS_PER_SECOND;
+var WALLET_SENT_TRANSFER_REFRESH_DELAY_MS = 3 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_BOOT_GRACE_MS = 15 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_HOT_AGE_MS = MINUTE_MS;
+var WALLET_PENDING_TRANSFER_WARM_AGE_MS = 10 * MINUTE_MS;
+var WALLET_PENDING_TRANSFER_WARM_RETRY_MS = 15 * MS_PER_SECOND;
+var WALLET_PENDING_TRANSFER_STALE_RETRY_MS = 2 * MINUTE_MS;
+var WALLET_PENDING_TRANSFER_STUCK_RETRY_MS = 10 * MINUTE_MS;
+var WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS = HOUR_MS;
+var WALLET_TRANSFER_CACHE_WRITE_DELAY_MS = 3 * MS_PER_SECOND;
+
 // ../../core/notifications.js
 "use client";
 var NOTIFICATION_DESCRIPTOR_VERSION = 1;
+var CHAT_ATTENTION_REGISTRATION_VERSION = 1;
+var CHAT_NOTIFICATION_MODES = Object.freeze({
+  ALL: "all",
+  MENTIONS: "mentions",
+  NONE: "none"
+});
+var CHAT_ATTENTION_KINDS = Object.freeze({
+  GENERAL: "general",
+  MENTION: "mention",
+  ROTATION: "rotation",
+  SILENT: "silent"
+});
 var HEX_32_RE = /^[0-9a-f]{64}$/u;
 var PEER_TAG_RE = /^[0-9a-f]{32}$/u;
+var ATTENTION_KINDS = new Set(Object.values(CHAT_ATTENTION_KINDS));
+var NOTIFICATION_MODES = new Set(Object.values(CHAT_NOTIFICATION_MODES));
+function hasCurrentChatAttentionRegistration(value) {
+  return value?.deliveryRegistered === true && value?.attentionRegistrationVersion === CHAT_ATTENTION_REGISTRATION_VERSION;
+}
 function cleanHex32(value, label) {
   const text = cleanText(value).toLowerCase();
   if (!HEX_32_RE.test(text)) {
@@ -5656,6 +5803,75 @@ function deriveChatDeliveryCapability(stateCapability, fields = {}) {
     cleanBytes(key);
   }
 }
+function cleanAttentionFields(fields = {}) {
+  return {
+    chatId: cleanHex32(fields.chatId, "attention chat id"),
+    recipientChatPK: cleanHex32(fields.recipientChatPK, "attention recipient chat key"),
+    generation: Number.isSafeInteger(fields.generation) && fields.generation > 0 ? fields.generation : 1
+  };
+}
+function deriveChatAttentionMaterial(attentionSecret, fields, kind) {
+  const normalized = cleanAttentionFields(fields);
+  const attentionKind = cleanText(kind);
+  if (!ATTENTION_KINDS.has(attentionKind)) {
+    throw new Error("chat attention kind required");
+  }
+  const key = deriveKey(toBytes32(attentionSecret, "chat attention secret"), "epoch-chat-attention-capability-v1", [normalized.chatId, normalized.recipientChatPK, normalized.generation, attentionKind]);
+  try {
+    return toHex(key);
+  } finally {
+    cleanBytes(key);
+  }
+}
+function deriveChatAttentionCapability(attentionSecret, fields = {}) {
+  return deriveChatAttentionMaterial(attentionSecret, fields, fields.kind);
+}
+function defaultChatNotificationMode(manifest) {
+  if (manifest?.lineage !== "group")
+    return CHAT_NOTIFICATION_MODES.ALL;
+  return manifest.members?.length > CHAT_ORDINARY_DELIVERY_MAX_MEMBERS ? CHAT_NOTIFICATION_MODES.MENTIONS : CHAT_NOTIFICATION_MODES.ALL;
+}
+function normalizeChatNotificationMode(value, manifest) {
+  const mode = cleanText(value);
+  if (!NOTIFICATION_MODES.has(mode))
+    throw new Error("chat notification mode required");
+  if (manifest?.lineage !== "group")
+    return CHAT_NOTIFICATION_MODES.ALL;
+  if (mode === CHAT_NOTIFICATION_MODES.ALL && manifest.members?.length > CHAT_ORDINARY_DELIVERY_MAX_MEMBERS) {
+    return CHAT_NOTIFICATION_MODES.MENTIONS;
+  }
+  return mode;
+}
+function chatAttentionCommitments(attentionSecret, fields = {}) {
+  const mode = normalizeChatNotificationMode(fields.notificationMode, fields.manifest);
+  const acceptedKinds = mode === CHAT_NOTIFICATION_MODES.ALL ? [CHAT_ATTENTION_KINDS.GENERAL, CHAT_ATTENTION_KINDS.MENTION] : mode === CHAT_NOTIFICATION_MODES.MENTIONS ? [CHAT_ATTENTION_KINDS.MENTION] : [];
+  const commitments = [...acceptedKinds, CHAT_ATTENTION_KINDS.ROTATION].map((kind) => deliveryCapabilityHash(deriveChatAttentionMaterial(attentionSecret, fields, kind)));
+  while (commitments.length < 3) {
+    const padding = toHex(randomBytes3(32));
+    if (!commitments.includes(padding))
+      commitments.push(padding);
+  }
+  return commitments.sort();
+}
+function chatDeliveryRegistration(stateCapability, fields = {}) {
+  const attentionFields = {
+    ...fields,
+    notificationMode: fields.notificationMode ?? defaultChatNotificationMode(fields.manifest)
+  };
+  return {
+    capability: deriveChatDeliveryCapability(stateCapability, fields),
+    attentionCommitments: chatAttentionCommitments(fields.attentionSecret, attentionFields),
+    singleUseAttentionCommitment: deliveryCapabilityHash(deriveChatAttentionMaterial(fields.attentionSecret, attentionFields, CHAT_ATTENTION_KINDS.ROTATION))
+  };
+}
+function deliveryCapabilityHash(value) {
+  const capability = fromHex(cleanHex32(value, "delivery capability"), "delivery capability");
+  try {
+    return toHex(sha256(capability));
+  } finally {
+    cleanBytes(capability);
+  }
+}
 function deriveChatInboxDeliveryId(stateCapability, fields = {}) {
   const chatId = cleanHex32(fields.chatId, "inbox delivery chat id");
   const recipientChatPK = cleanHex32(fields.recipientChatPK, "inbox delivery recipient chat key");
@@ -5900,135 +6116,6 @@ function isExtendedPictographic(cp) {
   return findUnicodeRangeCategory(cp, EXTENDED_PICTOGRAPHIC_S, EXTENDED_PICTOGRAPHIC_E) !== 0;
 }
 
-// ../../core/config.js
-var MS_PER_SECOND = 1000;
-var MINUTE_MS = 60 * MS_PER_SECOND;
-var HOUR_MS = 60 * MINUTE_MS;
-var DAY_MS = 24 * HOUR_MS;
-var KIB_BYTES = 1024;
-var MIB_BYTES = 1024 * 1024;
-var SATS_PER_BITCOIN = 100000000n;
-var USERNAME_MAX_CHARS = 12;
-var PASSWORD_MIN_CHARS = 15;
-var PASSWORD_MAX_CHARS = 64;
-var PASSWORD_MAX_BYTES = 4 * 1024;
-var LOCAL_MEDIA_CACHE_MAX_BYTES = 512 * MIB_BYTES;
-var LOCAL_PROFILE_CACHE_MAX_ITEMS = 500;
-var LOCAL_PROFILE_CACHE_MAX_AGE_MS = 30 * DAY_MS;
-var LOCAL_CHAT_CACHE_MAX_ITEMS = 1000;
-var LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000;
-var LOCAL_AVATAR_CACHE_MAX_BYTES = 128 * MIB_BYTES;
-var LOCAL_AVATAR_CACHE_MAX_AGE_MS = 30 * DAY_MS;
-var AVATAR_IMAGE_MAX_BYTES = 256 * KIB_BYTES;
-var AVATAR_IMAGE_QUALITY_ATTEMPTS = Object.freeze([0.92, 0.84, 0.76, 0.68]);
-var CHAT_AVATAR_IMAGE_MAX_BYTES = AVATAR_IMAGE_MAX_BYTES;
-var CHAT_AVATAR_REF_MAX_CHARS = 256;
-var CHAT_MESSAGE_FILE_CACHE_MAX_BYTES = 64 * MIB_BYTES;
-var IDLE_CALLBACK_MIN_TIMEOUT_MS = 50;
-var ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500;
-var ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250;
-var CHAT_UNSAVED_TTL_DAYS = 21;
-var CHAT_UNSAVED_TTL_MS = CHAT_UNSAVED_TTL_DAYS * DAY_MS;
-var CHAT_AFTER_SEEN_MS = DAY_MS;
-var CHAT_MEDIA_TTL_DAYS = CHAT_UNSAVED_TTL_DAYS;
-var CHAT_MEDIA_TTL_MS = CHAT_MEDIA_TTL_DAYS * DAY_MS;
-var CHAT_UPLOAD_MAX_BYTES = 64 * MIB_BYTES;
-var CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000;
-var CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000;
-var CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS = CHAT_AUDIO_TRANSCODE_BITRATE_BPS;
-var CHAT_MESSAGE_BATCH_SIZE = 40;
-var CHAT_MESSAGE_QUERY_MAX_DOCS = 120;
-var CHAT_MESSAGE_MUTATION_MAX_ITEMS = 256;
-var CHAT_TTL_CLIENT_DELETE_GRACE_MS = MINUTE_MS;
-var CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500;
-var CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250;
-var CHAT_LIST_PAGE_SIZE = 20;
-var CHAT_LIST_LIVE_COUNT = CHAT_LIST_PAGE_SIZE;
-var CHAT_INBOX_PING_PAGE_SIZE = 25;
-var CHAT_INBOX_DISCOVERY_PARALLEL_CHATS = CHAT_INBOX_PING_PAGE_SIZE;
-var CHAT_INBOX_SETTLEMENT_PARALLEL_CHATS = 4;
-var CHAT_INBOX_CURSOR_OVERLAP_MS = 5 * MS_PER_SECOND;
-var CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500;
-var CHAT_LIST_SNAPSHOT_COALESCE_MS = 80;
-var CHAT_LIST_COMPLETE_SYNC_DELAY_MS = 250;
-var CHAT_LIST_LISTENER_RETRY_MS = 1000;
-var CHAT_TOP_WARM_COUNT = 0;
-var CHAT_EAGER_WARM_COUNT = 0;
-var CHAT_WARM_DELAY_MS = 3000;
-var CHAT_WARM_BATCH_SIZE = CHAT_MESSAGE_BATCH_SIZE;
-var CHAT_MESSAGE_VIEW_CACHE_SIZE = 30;
-var CHAT_MEDIA_WARM_MESSAGES_PER_CHAT = CHAT_MESSAGE_BATCH_SIZE;
-var CHAT_MEDIA_WARM_START_DELAY_MS = 600;
-var CHAT_MEDIA_WARM_STEP_DELAY_MS = 120;
-var CHAT_MEDIA_WARM_TYPES = Object.freeze(["img", "gif", "mp4"]);
-var CHAT_MEDIA_WARM_MAX_BYTES = 0;
-var CHAT_READ_WRITE_INTERVAL_MS = 2 * MS_PER_SECOND;
-var CHAT_READ_WRITE_MAX_WAIT_MS = 8 * MS_PER_SECOND;
-var CHAT_LIVE_PING_INTERVAL_MS = 5 * MS_PER_SECOND;
-var CHAT_LIVE_SWEEP_INTERVAL_MS = 15 * MS_PER_SECOND;
-var CHAT_LIVE_STALE_AFTER_MS = 15 * MS_PER_SECOND;
-var CHAT_LIVE_RECONNECT_MAX_MS = 5 * MS_PER_SECOND;
-var CHAT_LIVE_TYPING_IDLE_MS = 8 * MS_PER_SECOND;
-var CHAT_LIVE_TYPING_RENEW_MS = 5 * MS_PER_SECOND;
-var CHAT_LIVE_COMPOSITION_HANDOFF_MS = 15 * MS_PER_SECOND;
-var CHAT_LIVE_READ_SEND_INTERVAL_MS = 120;
-var CHAT_LIVE_READ_SEND_MAX_WAIT_MS = 500;
-var CHAT_LIVE_READ_WRITE_INTERVAL_MS = 12 * MS_PER_SECOND;
-var CHAT_LIVE_READ_WRITE_MAX_WAIT_MS = 30 * MS_PER_SECOND;
-var CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12;
-var CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS = 10 * MS_PER_SECOND;
-var CHAT_SETTINGS_BODY_MAX_BYTES = 32 * KIB_BYTES;
-var CHAT_TITLE_STATE_MAX_CHARS = 128;
-var CHAT_MANIFEST_MAX_BYTES = 256 * KIB_BYTES;
-var CHAT_RECEIPT_MAX_MEMBERS = 32;
-var CHAT_ORDINARY_DELIVERY_MAX_MEMBERS = 128;
-var CHAT_MAX_MEMBERS = 256;
-var CHAT_MAX_TEXT_CHARS = 2048;
-var CHAT_TITLE_INPUT_MAX_CHARS = 16;
-var CHAT_MAX_REACTIONS = CHAT_MAX_MEMBERS;
-var SEARCH_DEBOUNCE_MS = 300;
-var RECENT_PEER_REFRESH_LIMIT = 50;
-var RECENT_PEER_REFRESH_DELAY_MS = 250;
-var RECENT_PEER_REFRESH_INTERVAL_MS = 5 * MINUTE_MS;
-var RECENT_PEER_REFRESH_THROTTLE_MS = 120;
-var BAN_REFRESH_GRACE_MS = 50;
-var REQUEST_MONEY_MAX_SATS = SATS_PER_BITCOIN * 100000n;
-var WALLET_TRANSFER_POLL_MS = 3 * MS_PER_SECOND;
-var WALLET_ACTIVE_TRANSFER_REFRESH_MS = MS_PER_SECOND;
-var WALLET_CACHE_HYDRATE_DELAY_MS = 0;
-var WALLET_BOOT_REFRESH_DELAY_MS = 500;
-var WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500;
-var WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS = 20 * MS_PER_SECOND;
-var WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS = MINUTE_MS;
-var WALLET_BALANCE_EVENT_COALESCE_MS = 2 * MS_PER_SECOND;
-var WALLET_INCOMING_UPDATE_COALESCE_MS = 250;
-var WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000;
-var WALLET_CLAIM_PAGE_SIZE = 100;
-var WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50;
-var WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2;
-var WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50;
-var WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS = 15 * MS_PER_SECOND;
-var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3;
-var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10;
-var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2;
-var WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3;
-var WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS = 4 * MS_PER_SECOND;
-var WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS = 15 * MS_PER_SECOND;
-var WALLET_SDK_BACKGROUND_QUIET_MS = MS_PER_SECOND;
-var WALLET_RECENT_TRANSFER_LIMIT = 100;
-var WALLET_TRANSFER_PAGE_LIMIT = 100;
-var WALLET_TRANSFER_FETCH_THROTTLE_MS = 150;
-var WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS = 3 * MS_PER_SECOND;
-var WALLET_SENT_TRANSFER_REFRESH_DELAY_MS = 3 * MS_PER_SECOND;
-var WALLET_PENDING_TRANSFER_BOOT_GRACE_MS = 15 * MS_PER_SECOND;
-var WALLET_PENDING_TRANSFER_HOT_AGE_MS = MINUTE_MS;
-var WALLET_PENDING_TRANSFER_WARM_AGE_MS = 10 * MINUTE_MS;
-var WALLET_PENDING_TRANSFER_WARM_RETRY_MS = 15 * MS_PER_SECOND;
-var WALLET_PENDING_TRANSFER_STALE_RETRY_MS = 2 * MINUTE_MS;
-var WALLET_PENDING_TRANSFER_STUCK_RETRY_MS = 10 * MINUTE_MS;
-var WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS = HOUR_MS;
-var WALLET_TRANSFER_CACHE_WRITE_DELAY_MS = 3 * MS_PER_SECOND;
-
 // ../../core/password.js
 var MIN_PASSWORD = PASSWORD_MIN_CHARS;
 var MAX_PASSWORD = PASSWORD_MAX_CHARS;
@@ -7281,7 +7368,7 @@ function closeSessionResources({ wallet, chatPK, chatPrivateKey, chatSigningSecr
   close(vaultAccess);
   close(vaultSigner);
   close(localCache);
-  pending.push(lockWallet(wallet));
+  lockWallet(wallet);
   lockChat(chatPrivateKey, chatPK);
   cleanBytes(chatSigningSecret, notificationPrivateKey, notificationPublicKey);
   return Promise.allSettled(pending).then(() => {
@@ -7670,7 +7757,7 @@ function cleanAvatarUsername(value) {
 }
 
 // ../../core/agreement.js
-var TERMS_VERSION = "2026-08-22.4";
+var TERMS_VERSION = "2026-09-01.1";
 var CURRENT_AGREEMENT = Object.freeze({
   termsVersion: TERMS_VERSION
 });
@@ -7802,6 +7889,312 @@ function nextBanRefreshMs(banned, keys = ["full", "chat"], now = Date.now()) {
   return times[0] ?? null;
 }
 
+// ../../core/chat/protocol.js
+"use client";
+var CHAT_PROTOCOL_VERSION = 3;
+var CHAT_MANIFEST_VERSION = 2;
+var CHAT_TRANSITION_VERSION = 2;
+var CHAT_MESSAGE_ENVELOPE_VERSION = 3;
+var CHAT_SETTINGS_VERSION = 1;
+
+// ../../core/chat/epochs/manifest.js
+"use client";
+var CHAT_LINEAGES = Object.freeze({
+  SELF: "self",
+  DIRECT: "direct",
+  GROUP: "group"
+});
+var LINEAGES = new Set(Object.values(CHAT_LINEAGES));
+var HEX_32_RE2 = /^[0-9a-f]{64}$/u;
+function cleanChatHex(value, label = "chat value") {
+  const text = cleanText(value).toLowerCase();
+  if (!HEX_32_RE2.test(text)) {
+    throw new Error(`${label} required`);
+  }
+  return text;
+}
+function cleanUid(value) {
+  const uid = cleanText(value);
+  if (!uid || uid.length > 128) {
+    throw new Error("chat member uid required");
+  }
+  return uid;
+}
+function cleanCreatedAt(value) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error("chat epoch createdAt required");
+  }
+  return value;
+}
+function cleanEpochVersion(value) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new Error("chat epoch version required");
+  }
+  return value;
+}
+function cleanMember(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("invalid chat member");
+  }
+  return {
+    uid: cleanUid(value.uid),
+    chatPK: cleanChatHex(value.chatPK, "member chat key"),
+    chatSigningPK: cleanChatHex(value.chatSigningPK, "member signing key"),
+    notificationPK: cleanChatHex(value.notificationPK, "member notification key"),
+    mlsLeafId: cleanChatHex(value.mlsLeafId, "member mls leaf id")
+  };
+}
+function assertUniqueMembers(members) {
+  const uids = new Set;
+  const chatKeys = new Set;
+  const signingKeys = new Set;
+  const mlsLeafIds = new Set;
+  for (const member of members) {
+    if (uids.has(member.uid) || chatKeys.has(member.chatPK) || signingKeys.has(member.chatSigningPK) || mlsLeafIds.has(member.mlsLeafId)) {
+      throw new Error("duplicate chat member");
+    }
+    uids.add(member.uid);
+    chatKeys.add(member.chatPK);
+    signingKeys.add(member.chatSigningPK);
+    mlsLeafIds.add(member.mlsLeafId);
+  }
+}
+function assertLineage(manifest, parent) {
+  const memberCount = manifest.members.length;
+  if (memberCount > 2 && manifest.lineage !== CHAT_LINEAGES.GROUP) {
+    throw new Error("group lineage required");
+  }
+  if (!parent) {
+    return;
+  }
+  if (manifest.chatId !== parent.chatId || manifest.parentEpochId !== parent.epochId || manifest.epochVersion !== parent.epochVersion + 1) {
+    throw new Error("invalid chat epoch successor");
+  }
+  if (parent.lineage === CHAT_LINEAGES.GROUP && manifest.lineage !== CHAT_LINEAGES.GROUP) {
+    throw new Error("chat group lineage is permanent");
+  }
+}
+function normalizeEpochManifest(value, options = {}) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("chat manifest required");
+  }
+  if (value.v !== CHAT_MANIFEST_VERSION || value.protocol !== CHAT_PROTOCOL_VERSION) {
+    throw new Error("unsupported chat manifest");
+  }
+  if (!Array.isArray(value.members) || value.members.length < 1 || value.members.length > CHAT_MAX_MEMBERS) {
+    throw new Error("invalid chat member count");
+  }
+  const lineage = cleanText(value.lineage);
+  if (!LINEAGES.has(lineage)) {
+    throw new Error("invalid chat lineage");
+  }
+  const members = value.members.map(cleanMember).sort((a, b) => a.chatPK.localeCompare(b.chatPK));
+  assertUniqueMembers(members);
+  const manifest = {
+    v: CHAT_MANIFEST_VERSION,
+    protocol: CHAT_PROTOCOL_VERSION,
+    chatId: cleanChatHex(value.chatId, "chat id"),
+    epochId: cleanChatHex(value.epochId, "chat epoch id"),
+    epochVersion: cleanEpochVersion(value.epochVersion),
+    parentEpochId: value.parentEpochId == null ? null : cleanChatHex(value.parentEpochId, "parent epoch id"),
+    createdAt: cleanCreatedAt(value.createdAt),
+    lineage,
+    members
+  };
+  if (manifest.epochVersion === 1 !== (manifest.parentEpochId === null)) {
+    throw new Error("invalid parent epoch");
+  }
+  const bytes = canonicalBytes(manifest, "chat manifest");
+  if (bytes.length > CHAT_MANIFEST_MAX_BYTES) {
+    throw new Error("chat manifest too large");
+  }
+  assertLineage(manifest, options.parent || null);
+  return manifest;
+}
+function epochManifestDigest(manifest) {
+  return toHex(sha256(canonicalBytes(normalizeEpochManifest(manifest), "chat manifest digest")));
+}
+function manifestMember(manifest, chatPK) {
+  const key = cleanChatHex(chatPK, "member chat key");
+  return normalizeEpochManifest(manifest).members.find((member) => member.chatPK === key) || null;
+}
+function manifestSigningKeys(manifest) {
+  return Object.fromEntries(normalizeEpochManifest(manifest).members.map((member) => [member.chatPK, member.chatSigningPK]));
+}
+
+// ../../core/chat/admission.js
+"use client";
+var CHAT_ADMISSION_VERSION = 1;
+var CHAT_ADMISSION_GRANT_COUNT = 8;
+var CHAT_ADMISSION_DECISIONS = Object.freeze({
+  ACCEPT: "accept",
+  REQUEST: "request",
+  REJECT: "reject"
+});
+var CHAT_DIRECT_ADMISSION_MODES = Object.freeze({
+  OPEN: "open",
+  REQUESTS: "requests",
+  CLOSED: "closed"
+});
+var CHAT_GROUP_ADMISSION_MODES = Object.freeze({
+  OPEN: "open",
+  CLOSED: "closed"
+});
+var HEX_32_RE3 = /^[0-9a-f]{64}$/u;
+var DIRECT_MODES = new Set(Object.values(CHAT_DIRECT_ADMISSION_MODES));
+var GROUP_MODES = new Set(Object.values(CHAT_GROUP_ADMISSION_MODES));
+var DECISION_RANK = Object.freeze({ accept: 0, request: 1, reject: 2 });
+var DEFAULT_ADMISSION = Object.freeze({
+  v: CHAT_ADMISSION_VERSION,
+  direct: CHAT_DIRECT_ADMISSION_MODES.OPEN,
+  groups: CHAT_GROUP_ADMISSION_MODES.OPEN,
+  directGrants: Object.freeze([])
+});
+var CLOSED_ADMISSION = Object.freeze({
+  v: CHAT_ADMISSION_VERSION,
+  direct: CHAT_DIRECT_ADMISSION_MODES.CLOSED,
+  groups: CHAT_GROUP_ADMISSION_MODES.CLOSED,
+  directGrants: Object.freeze([])
+});
+function validGrantList(value) {
+  return Array.isArray(value) && value.length === CHAT_ADMISSION_GRANT_COUNT && value.every((item) => typeof item === "string" && HEX_32_RE3.test(item)) && new Set(value).size === value.length && value.every((item, index) => index === 0 || value[index - 1] < item);
+}
+function normalizeChatAdmission(value) {
+  if (value == null)
+    return DEFAULT_ADMISSION;
+  if (typeof value !== "object" || Array.isArray(value) || value.v !== CHAT_ADMISSION_VERSION || !DIRECT_MODES.has(value.direct) || !GROUP_MODES.has(value.groups) || !validGrantList(value.directGrants))
+    return CLOSED_ADMISSION;
+  return Object.freeze({
+    v: CHAT_ADMISSION_VERSION,
+    direct: value.direct,
+    groups: value.groups,
+    directGrants: Object.freeze([...value.directGrants])
+  });
+}
+function normalizeChatAdmissionDecision(value) {
+  return Object.values(CHAT_ADMISSION_DECISIONS).includes(value) ? value : CHAT_ADMISSION_DECISIONS.REJECT;
+}
+function strictestChatAdmissionDecision(...values) {
+  return values.map(normalizeChatAdmissionDecision).reduce((strictest, value) => DECISION_RANK[value] > DECISION_RANK[strictest] ? value : strictest, CHAT_ADMISSION_DECISIONS.ACCEPT);
+}
+function orderedChatKeys(first, second) {
+  return [
+    cleanChatHex(first, "chat public key"),
+    cleanChatHex(second, "peer chat public key")
+  ].sort();
+}
+function deriveDirectAdmissionCapability(chatPrivateKey, chatPK, peerChatPK, recipientChatPK) {
+  const ownChatPK = cleanChatHex(chatPK, "chat public key");
+  const otherChatPK = cleanChatHex(peerChatPK, "peer chat public key");
+  const recipient = cleanChatHex(recipientChatPK, "recipient chat public key");
+  if (ownChatPK === otherChatPK || ![ownChatPK, otherChatPK].includes(recipient)) {
+    throw new Error("direct admission peer required");
+  }
+  let peerKey = null;
+  let shared = null;
+  let capability = null;
+  try {
+    peerKey = fromHex(otherChatPK, "peer chat public key");
+    shared = x25519.getSharedSecret(toBytes32(chatPrivateKey, "chat private key"), peerKey);
+    capability = deriveKey(shared.subarray(0, 32), "direct-chat-admission-capability-v1", [...orderedChatKeys(ownChatPK, otherChatPK), recipient]);
+    return toHex(capability);
+  } finally {
+    cleanBytes(peerKey, shared, capability);
+  }
+}
+function chatAdmissionCapabilityCommitment(value) {
+  let capability = null;
+  try {
+    capability = fromHex(value, "chat admission capability");
+    return toHex(sha256(capability));
+  } finally {
+    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 directAdmissionForPeer(chatPrivateKey, chatPK, profile) {
+  if (hasDirectAdmissionGrant(chatPrivateKey, chatPK, profile)) {
+    return CHAT_ADMISSION_DECISIONS.ACCEPT;
+  }
+  const mode = normalizeChatAdmission(profile?.chatAdmission).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) {
+  return directAdmissionForPeer(chatPrivateKey, chatPK, profile) !== CHAT_ADMISSION_DECISIONS.REJECT;
+}
+function canInviteToGroup(profile) {
+  return normalizeChatAdmission(profile?.chatAdmission).groups === CHAT_GROUP_ADMISSION_MODES.OPEN;
+}
+function incomingChatAdmissionDecision(chatPrivateKey, chatPK, senderProfile, recipientAdmission, lineage) {
+  const policy = normalizeChatAdmission(recipientAdmission);
+  if (lineage === "direct") {
+    const capability = deriveDirectAdmissionCapability(chatPrivateKey, chatPK, senderProfile?.chatPK, chatPK);
+    try {
+      if (policy.directGrants.includes(chatAdmissionCapabilityCommitment(capability))) {
+        return CHAT_ADMISSION_DECISIONS.ACCEPT;
+      }
+    } finally {
+      cleanBytes(capability);
+    }
+    if (policy.direct === CHAT_DIRECT_ADMISSION_MODES.OPEN)
+      return CHAT_ADMISSION_DECISIONS.ACCEPT;
+    if (policy.direct === CHAT_DIRECT_ADMISSION_MODES.REQUESTS)
+      return CHAT_ADMISSION_DECISIONS.REQUEST;
+    return CHAT_ADMISSION_DECISIONS.REJECT;
+  }
+  return lineage === "group" && policy.groups === CHAT_GROUP_ADMISSION_MODES.OPEN ? CHAT_ADMISSION_DECISIONS.ACCEPT : CHAT_ADMISSION_DECISIONS.REJECT;
+}
+function makeChatAdmission(chatPrivateKey, chatPK, options = {}) {
+  const direct = options.direct || CHAT_DIRECT_ADMISSION_MODES.OPEN;
+  const groups = options.groups || CHAT_GROUP_ADMISSION_MODES.OPEN;
+  if (!DIRECT_MODES.has(direct) || !GROUP_MODES.has(groups)) {
+    throw new Error("valid chat admission modes required");
+  }
+  const peers = [...new Map((options.allow || []).map((profile) => {
+    const peerChatPK = cleanChatHex(profile?.chatPK, "allowed peer chat public key");
+    return [peerChatPK, profile];
+  })).values()];
+  if (peers.length > CHAT_ADMISSION_GRANT_COUNT) {
+    throw new Error(`chat admission allows at most ${CHAT_ADMISSION_GRANT_COUNT} direct peers`);
+  }
+  const commitments = peers.map((profile) => {
+    const capability = deriveDirectAdmissionCapability(chatPrivateKey, chatPK, profile.chatPK, chatPK);
+    try {
+      return chatAdmissionCapabilityCommitment(capability);
+    } finally {
+      cleanBytes(capability);
+    }
+  });
+  while (commitments.length < CHAT_ADMISSION_GRANT_COUNT) {
+    const padding = toHex(randomBytes3(32));
+    if (!commitments.includes(padding))
+      commitments.push(padding);
+  }
+  return Object.freeze({
+    v: CHAT_ADMISSION_VERSION,
+    direct,
+    groups,
+    directGrants: Object.freeze(commitments.sort())
+  });
+}
+
 // ../../core/profile.js
 var BOT_PROFILE_MARKER = "glyphteck";
 function readBotMarker(profile) {
@@ -7834,6 +8227,7 @@ function normalizeProfile(profile, uid = profile?.uid || null) {
     chatPK: profile?.chatPK || null,
     chatSigningPK: profile?.chatSigningPK || null,
     notificationPK: profile?.notificationPK || null,
+    chatAdmission: normalizeChatAdmission(profile?.chatAdmission),
     active: profile?.active ?? false,
     bot: readBotMarker(profile),
     avatarVersion: readAvatarVersion(profile?.avatarVersion),
@@ -7857,6 +8251,8 @@ function settingsState(settings = defaultSettings) {
 var defaultUser = {
   uid: null,
   authReady: false,
+  authSessionReady: false,
+  authSessionActive: false,
   authCredential: null,
   profileReady: false,
   username: null,
@@ -7870,6 +8266,7 @@ var defaultUser = {
   chatPK: null,
   chatSigningPK: null,
   notificationPK: null,
+  chatAdmission: normalizeChatAdmission(null),
   active: false,
   banned: null,
   agreement: null,
@@ -7878,12 +8275,16 @@ var defaultUser = {
   settingsReady: false,
   settings: settingsState()
 };
+function isAccountAuthenticationError(error) {
+  const code = typeof error?.code === "string" ? error.code.toLowerCase() : "";
+  return code === "permission-denied" || code.endsWith("/permission-denied") || code === "unauthenticated" || code.endsWith("/unauthenticated");
+}
 function createUser({ cloud, network, avatarCache = null, diag = null, onSessionRevoked = null }) {
   if (!cloud) {
     throw new Error("createUser requires { cloud }");
   }
-  if (avatarCache && [avatarCache.read, avatarCache.write, avatarCache.remove, avatarCache.removeAll].some((method) => typeof method !== "function")) {
-    throw new Error("avatarCache requires read, write, remove, and removeAll");
+  if (avatarCache && [avatarCache.read, avatarCache.write, avatarCache.remove].some((method) => typeof method !== "function")) {
+    throw new Error("avatarCache requires read, write, and remove");
   }
   let activeNetwork = network;
   let state = defaultUser;
@@ -7980,7 +8381,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     if (!uid || !avatarCache)
       return null;
     try {
-      const cached = await avatarCache.read(uid);
+      const cached = await avatarCache.read(uid, expectedVersion);
       const version = readAvatarVersion(cached?.version);
       if (expectedVersion != null && version !== expectedVersion) {
         return null;
@@ -8021,9 +8422,6 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       return;
     runCacheTask("user.avatar.cache.remove", () => avatarCache.remove(uid));
   }
-  function clearCachedAvatars() {
-    runCacheTask("user.avatar.cache.clear", () => avatarCache.removeAll());
-  }
   async function fetchAvatar(uid, { version = null, force = false, clear = false, persist = true } = {}) {
     if (!uid)
       return;
@@ -8106,6 +8504,54 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
   function isCurrentUser(uid, session) {
     return started && authSession === session && userUid === uid;
   }
+  function revokeAuthentication(authUser, {
+    code = "",
+    local = false,
+    reason = "session-inactive"
+  } = {}) {
+    if (revokingSession)
+      return;
+    revokingSession = true;
+    let callback;
+    try {
+      callback = onSessionRevoked?.({
+        uid: authUser.uid,
+        code,
+        reason
+      });
+    } catch (error) {
+      callback = Promise.reject(error);
+    }
+    markDiag(diag, "user.auth.revoked", {
+      code,
+      local,
+      reason
+    });
+    setState((user) => ({
+      ...user,
+      authSessionReady: true,
+      authSessionActive: false,
+      authCredential: null
+    }));
+    let operation = Promise.resolve(callback).catch((error) => markError(diag, "user.session.revoke.local", Date.now(), error));
+    if (!local) {
+      operation = operation.then(() => cloud.auth.logout()).catch((error) => markError(diag, "user.session.revoke.auth", Date.now(), error));
+    }
+    operation.finally(() => {
+      if (userUid === authUser.uid) {
+        revokingSession = false;
+      }
+    });
+  }
+  function revokeAuthenticationError(authUser, error, reason) {
+    if (!isAccountAuthenticationError(error))
+      return false;
+    revokeAuthentication(authUser, {
+      code: error?.code || "",
+      reason
+    });
+    return true;
+  }
   function watchUser(authUser) {
     if (!started)
       return;
@@ -8115,7 +8561,6 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     closeUserWatches();
     markDiag(diag, "user.auth.state", { signedIn: !!authUser });
     if (!authUser) {
-      const signedOutUid = userUid;
       revokingSession = false;
       userUid = null;
       clearSettingsKey(settingsKey);
@@ -8124,17 +8569,11 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       agreementStored = null;
       agreementOverride = null;
       agreementAcceptance = null;
-      if (signedOutUid) {
-        clearCachedAvatars();
-      }
       avatarFetch = { uid: null, key: null, promise: null };
       setState({ ...defaultUser, authReady: true });
       return;
     }
     const authUidChanged = userUid !== authUser.uid;
-    if (userUid && authUidChanged) {
-      clearCachedAvatars();
-    }
     userUid = authUser.uid;
     if (authUidChanged) {
       clearSettingsKey(settingsKey);
@@ -8164,32 +8603,28 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
     userWatches.push(cloud.auth.session.watch(authUser.uid, current((authSessionState) => {
       if (authSessionState?.active) {
         const authCredential = authSessionState.authCredential;
-        setState((user) => user.authCredential?.kind === authCredential?.kind && user.authCredential?.id === authCredential?.id ? user : { ...user, authCredential });
-        return;
-      }
-      if (revokingSession)
-        return;
-      revokingSession = true;
-      if (cloud.auth.session.isLocalTermination?.(authUser.uid, authSessionState?.generation)) {
-        Promise.resolve(onSessionRevoked?.({ uid: authUser.uid })).catch((error) => markError(diag, "user.session.revoke.local", Date.now(), error)).finally(() => {
-          if (userUid === authUser.uid) {
-            revokingSession = false;
-          }
+        setState((user) => user.authSessionReady && user.authSessionActive && user.authCredential?.kind === authCredential?.kind && user.authCredential?.id === authCredential?.id ? user : {
+          ...user,
+          authSessionReady: true,
+          authSessionActive: true,
+          authCredential
         });
         return;
       }
-      Promise.resolve(onSessionRevoked?.({ uid: authUser.uid })).catch((error) => markError(diag, "user.session.revoke.local", Date.now(), error)).then(() => cloud.auth.logout()).catch((error) => markError(diag, "user.session.revoke.auth", Date.now(), error)).finally(() => {
-        if (userUid === authUser.uid) {
-          revokingSession = false;
-        }
+      revokeAuthentication(authUser, {
+        local: cloud.auth.session.isLocalTermination?.(authUser.uid, authSessionState?.generation) === true,
+        reason: "session-inactive"
       });
     }), current((error) => {
       markError(diag, "user.session.listen", authStartedAt, error);
+      revokeAuthenticationError(authUser, error, "session-listener");
     })));
     userWatches.push(cloud.user.admin.watch(authUser.uid, current((allowed) => {
       setState((user) => ({ ...user, isAdmin: allowed, adminReady: true }));
     }), current((error) => {
       markError(diag, "user.admin.listen", authStartedAt, error);
+      if (revokeAuthenticationError(authUser, error, "admin-listener"))
+        return;
       setState((user) => ({ ...user, isAdmin: false, adminReady: true }));
     })));
     userWatches.push(cloud.user.private.watch(authUser.uid, current((privateData, info = {}) => {
@@ -8213,6 +8648,8 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       }));
     }), current((error) => {
       markError(diag, "user.settings.snapshot", authStartedAt, error);
+      if (revokeAuthenticationError(authUser, error, "settings-listener"))
+        return;
       settingsStored = null;
       agreementStored = null;
       setState((user) => ({
@@ -8225,6 +8662,8 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       setState((user) => ({ ...user, banned: banned ?? null }));
     }), current((error) => {
       markError(diag, "user.moderation.listen", authStartedAt, error);
+      if (revokeAuthenticationError(authUser, error, "moderation-listener"))
+        return;
       setState((user) => ({ ...user, banned: null }));
     })));
     userWatches.push(cloud.user.blocked.watch(authUser.uid, current((blocked, info = {}) => {
@@ -8237,6 +8676,8 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       });
     }), current((error) => {
       markError(diag, "user.blocked.listen", authStartedAt, error);
+      if (revokeAuthenticationError(authUser, error, "blocked-listener"))
+        return;
       setState((user) => ({ ...user, blockedReady: false }));
     })));
     userWatches.push(cloud.user.profile.watch(authUser.uid, current((profileData, info = {}) => {
@@ -8250,14 +8691,15 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
         const walletPK = resolveWalletPK(profileData, activeNetwork);
         const { chatPK, chatSigningPK } = readProfileChatIdentity(profileData);
         const notificationPK = readProfileNotificationPK(profileData);
+        const chatAdmission = normalizeChatAdmission(profileData.chatAdmission);
         const active = profileData.active ?? false;
         const hasAvatarEntry = !!info.exists && Object.prototype.hasOwnProperty.call(profileData, "avatar");
         const avatarVersion2 = readAvatarVersion(profileData.avatar);
         const avatar = avatarVersion2 == null ? null : user.avatar;
-        if (user.profileReady && user.uid === authUser.uid && user.username === username && user.identities === identities && user.walletPK === walletPK && user.chatPK === chatPK && user.chatSigningPK === chatSigningPK && user.notificationPK === notificationPK && user.active === active && user.hasAvatarEntry === hasAvatarEntry && user.avatarVersion === avatarVersion2 && user.avatar === avatar) {
+        if (user.profileReady && user.uid === authUser.uid && user.username === username && user.identities === identities && user.walletPK === walletPK && user.chatPK === chatPK && user.chatSigningPK === chatSigningPK && user.notificationPK === notificationPK && user.chatAdmission === chatAdmission && user.active === active && user.hasAvatarEntry === hasAvatarEntry && user.avatarVersion === avatarVersion2 && user.avatar === avatar) {
           return user;
         }
-        return { ...user, uid: authUser.uid, profileReady: true, username, identities, walletPK, chatPK, chatSigningPK, notificationPK, active, hasAvatarEntry, avatarVersion: avatarVersion2, avatar };
+        return { ...user, uid: authUser.uid, profileReady: true, username, identities, walletPK, chatPK, chatSigningPK, notificationPK, chatAdmission, active, hasAvatarEntry, avatarVersion: avatarVersion2, avatar };
       });
       const avatarVersion = readAvatarVersion(profileData.avatar);
       if (avatarVersion == null) {
@@ -8283,6 +8725,8 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
       }
     }), current((error) => {
       markError(diag, "user.profile.snapshot", authStartedAt, error);
+      if (revokeAuthenticationError(authUser, error, "profile-listener"))
+        return;
       avatarFetch = { uid: null, key: null, promise: null };
       setState((user) => ({
         ...user,
@@ -8294,6 +8738,7 @@ function createUser({ cloud, network, avatarCache = null, diag = null, onSession
         chatPK: null,
         chatSigningPK: null,
         notificationPK: null,
+        chatAdmission: normalizeChatAdmission(null),
         active: false,
         avatarVersion: null,
         avatar: null,
@@ -8636,139 +9081,6 @@ async function pushCriticalInbox(cloud, recipientUid, ping, options = {}, retry
 }
 var criticalDeliveryInternals = Object.freeze({ retryableDeliveryError });
 
-// ../../core/chat/protocol.js
-"use client";
-var CHAT_PROTOCOL_VERSION = 3;
-var CHAT_MANIFEST_VERSION = 2;
-var CHAT_TRANSITION_VERSION = 2;
-var CHAT_MESSAGE_ENVELOPE_VERSION = 3;
-var CHAT_SETTINGS_VERSION = 1;
-
-// ../../core/chat/epochs/manifest.js
-"use client";
-var CHAT_LINEAGES = Object.freeze({
-  SELF: "self",
-  DIRECT: "direct",
-  GROUP: "group"
-});
-var LINEAGES = new Set(Object.values(CHAT_LINEAGES));
-var HEX_32_RE2 = /^[0-9a-f]{64}$/u;
-function cleanChatHex(value, label = "chat value") {
-  const text = cleanText(value).toLowerCase();
-  if (!HEX_32_RE2.test(text)) {
-    throw new Error(`${label} required`);
-  }
-  return text;
-}
-function cleanUid(value) {
-  const uid = cleanText(value);
-  if (!uid || uid.length > 128) {
-    throw new Error("chat member uid required");
-  }
-  return uid;
-}
-function cleanCreatedAt(value) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new Error("chat epoch createdAt required");
-  }
-  return value;
-}
-function cleanEpochVersion(value) {
-  if (!Number.isSafeInteger(value) || value <= 0) {
-    throw new Error("chat epoch version required");
-  }
-  return value;
-}
-function cleanMember(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("invalid chat member");
-  }
-  return {
-    uid: cleanUid(value.uid),
-    chatPK: cleanChatHex(value.chatPK, "member chat key"),
-    chatSigningPK: cleanChatHex(value.chatSigningPK, "member signing key"),
-    notificationPK: cleanChatHex(value.notificationPK, "member notification key"),
-    mlsLeafId: cleanChatHex(value.mlsLeafId, "member mls leaf id")
-  };
-}
-function assertUniqueMembers(members) {
-  const uids = new Set;
-  const chatKeys = new Set;
-  const signingKeys = new Set;
-  const mlsLeafIds = new Set;
-  for (const member of members) {
-    if (uids.has(member.uid) || chatKeys.has(member.chatPK) || signingKeys.has(member.chatSigningPK) || mlsLeafIds.has(member.mlsLeafId)) {
-      throw new Error("duplicate chat member");
-    }
-    uids.add(member.uid);
-    chatKeys.add(member.chatPK);
-    signingKeys.add(member.chatSigningPK);
-    mlsLeafIds.add(member.mlsLeafId);
-  }
-}
-function assertLineage(manifest, parent) {
-  const memberCount = manifest.members.length;
-  if (memberCount > 2 && manifest.lineage !== CHAT_LINEAGES.GROUP) {
-    throw new Error("group lineage required");
-  }
-  if (!parent) {
-    return;
-  }
-  if (manifest.chatId !== parent.chatId || manifest.parentEpochId !== parent.epochId || manifest.epochVersion !== parent.epochVersion + 1) {
-    throw new Error("invalid chat epoch successor");
-  }
-  if (parent.lineage === CHAT_LINEAGES.GROUP && manifest.lineage !== CHAT_LINEAGES.GROUP) {
-    throw new Error("chat group lineage is permanent");
-  }
-}
-function normalizeEpochManifest(value, options = {}) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    throw new Error("chat manifest required");
-  }
-  if (value.v !== CHAT_MANIFEST_VERSION || value.protocol !== CHAT_PROTOCOL_VERSION) {
-    throw new Error("unsupported chat manifest");
-  }
-  if (!Array.isArray(value.members) || value.members.length < 1 || value.members.length > CHAT_MAX_MEMBERS) {
-    throw new Error("invalid chat member count");
-  }
-  const lineage = cleanText(value.lineage);
-  if (!LINEAGES.has(lineage)) {
-    throw new Error("invalid chat lineage");
-  }
-  const members = value.members.map(cleanMember).sort((a, b) => a.chatPK.localeCompare(b.chatPK));
-  assertUniqueMembers(members);
-  const manifest = {
-    v: CHAT_MANIFEST_VERSION,
-    protocol: CHAT_PROTOCOL_VERSION,
-    chatId: cleanChatHex(value.chatId, "chat id"),
-    epochId: cleanChatHex(value.epochId, "chat epoch id"),
-    epochVersion: cleanEpochVersion(value.epochVersion),
-    parentEpochId: value.parentEpochId == null ? null : cleanChatHex(value.parentEpochId, "parent epoch id"),
-    createdAt: cleanCreatedAt(value.createdAt),
-    lineage,
-    members
-  };
-  if (manifest.epochVersion === 1 !== (manifest.parentEpochId === null)) {
-    throw new Error("invalid parent epoch");
-  }
-  const bytes = canonicalBytes(manifest, "chat manifest");
-  if (bytes.length > CHAT_MANIFEST_MAX_BYTES) {
-    throw new Error("chat manifest too large");
-  }
-  assertLineage(manifest, options.parent || null);
-  return manifest;
-}
-function epochManifestDigest(manifest) {
-  return toHex(sha256(canonicalBytes(normalizeEpochManifest(manifest), "chat manifest digest")));
-}
-function manifestMember(manifest, chatPK) {
-  const key = cleanChatHex(chatPK, "member chat key");
-  return normalizeEpochManifest(manifest).members.find((member) => member.chatPK === key) || null;
-}
-function manifestSigningKeys(manifest) {
-  return Object.fromEntries(normalizeEpochManifest(manifest).members.map((member) => [member.chatPK, member.chatSigningPK]));
-}
-
 // ../../core/chat/epochs/state.js
 "use client";
 var CAPABILITY_WITNESS_SCOPE = "veyl-chat-state-witness-v3:";
@@ -9980,6 +10292,7 @@ function epochChatSettingsId(epochState) {
 "use client";
 var CHAT_ENTRY_VERSION = 4;
 var CHAT_OWNER_EPOCH_ENTRY_VERSION = 2;
+var CHAT_NOTIFICATION_PREFERENCE_VERSION = 1;
 var CHAT_OWNER_RETIREMENT_KINDS = Object.freeze({
   LEAVE: "leave",
   REMOVED: "removed"
@@ -10001,6 +10314,16 @@ function entryKey(chatPrivateKey, entryId) {
 function entryAad(entryId) {
   return canonicalBytes({ v: CHAT_ENTRY_VERSION, protocol: CHAT_PROTOCOL_VERSION, entryId }, "chat entry aad");
 }
+function notificationPreferenceKey(chatPrivateKey, entryId) {
+  return deriveKey(toBytes32(chatPrivateKey, "chat private key"), "user-chat-notification-preference-v1", [cleanText(entryId)]);
+}
+function notificationPreferenceAad(entryId) {
+  return canonicalBytes({
+    v: CHAT_NOTIFICATION_PREFERENCE_VERSION,
+    protocol: CHAT_PROTOCOL_VERSION,
+    entryId
+  }, "chat notification preference aad");
+}
 function ownerEpochKey(chatPrivateKey, entryId, epochEntryId) {
   return deriveKey(toBytes32(chatPrivateKey, "chat private key"), "user-chat-epoch-entry-v3", [entryId, epochEntryId]);
 }
@@ -10036,12 +10359,13 @@ function normalizeRoutes(value) {
     }
     const uid = cleanText(route.uid);
     const deliveryCapability = route.deliveryCapability == null ? null : cleanChatHex(route.deliveryCapability, "delivery capability");
+    const admissionCapability = route.admissionCapability == null ? null : cleanChatHex(route.admissionCapability, "admission capability");
     const notificationPK = route.notificationPK == null ? null : cleanChatHex(route.notificationPK, "notification key");
     const generation = Number.isSafeInteger(route.generation) && route.generation > 0 ? route.generation : 1;
     if (!uid || uid.length > 128) {
       throw new Error("chat route uid required");
     }
-    routes[chatPK] = { uid, deliveryCapability, notificationPK, generation };
+    routes[chatPK] = { uid, deliveryCapability, admissionCapability, notificationPK, generation };
   }
   return routes;
 }
@@ -10098,6 +10422,32 @@ function normalizeOwnerEntry(value) {
     retirement: normalizeOwnerRetirement(value.retirement, current)
   };
 }
+function withNotificationPreference(entry, value = {}) {
+  const manifest = entry.current.manifest;
+  const notificationMode = normalizeChatNotificationMode(value.notificationMode ?? defaultChatNotificationMode(manifest), manifest);
+  const registrationMatches = value.registeredEpochId === manifest.epochId && value.attentionRegistrationVersion === CHAT_ATTENTION_REGISTRATION_VERSION;
+  return {
+    ...entry,
+    attentionRegistrationVersion: registrationMatches ? CHAT_ATTENTION_REGISTRATION_VERSION : 0,
+    notificationMode
+  };
+}
+function normalizeNotificationPreference(value, entry) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || value.v !== CHAT_NOTIFICATION_PREFERENCE_VERSION || value.protocol !== CHAT_PROTOCOL_VERSION) {
+    throw new Error("invalid chat notification preference");
+  }
+  const manifest = entry.current.manifest;
+  const notificationMode = normalizeChatNotificationMode(value.notificationMode, manifest);
+  const registeredEpochId = value.registeredEpochId == null ? null : cleanChatHex(value.registeredEpochId, "registered chat epoch id");
+  const attentionRegistrationVersion = registeredEpochId === manifest.epochId && value.attentionRegistrationVersion === CHAT_ATTENTION_REGISTRATION_VERSION ? CHAT_ATTENTION_REGISTRATION_VERSION : 0;
+  return {
+    v: CHAT_NOTIFICATION_PREFERENCE_VERSION,
+    protocol: CHAT_PROTOCOL_VERSION,
+    notificationMode,
+    registeredEpochId: attentionRegistrationVersion ? registeredEpochId : null,
+    attentionRegistrationVersion
+  };
+}
 async function sealOwnChatEntry(chatPrivateKey, entryId, entry) {
   const key = entryKey(chatPrivateKey, entryId);
   try {
@@ -10111,14 +10461,14 @@ async function openOwnChatEntry(chatPrivateKey, entryId, body) {
   const key = entryKey(chatPrivateKey, entryId);
   try {
     const { nonce, ct } = unpackBodyData(body);
-    return normalizeOwnerEntry(await openJson(key, nonce, ct, entryAad(entryId)));
+    return withNotificationPreference(normalizeOwnerEntry(await openJson(key, nonce, ct, entryAad(entryId))));
   } finally {
     cleanBytes(key);
   }
 }
 function makeOwnChatEntry(epoch, fields = {}) {
   const manifest = normalizeEpochManifest(epoch?.manifest);
-  return normalizeOwnerEntry({
+  const entry = normalizeOwnerEntry({
     v: CHAT_ENTRY_VERSION,
     protocol: CHAT_PROTOCOL_VERSION,
     ownerRevision: Number.isSafeInteger(fields.ownerRevision) && fields.ownerRevision > 0 ? fields.ownerRevision : 1,
@@ -10139,6 +10489,48 @@ function makeOwnChatEntry(epoch, fields = {}) {
     notificationTag: cleanText(fields.notificationTag) || null,
     retirement: fields.retirement || null
   });
+  return withNotificationPreference(entry, {
+    attentionRegistrationVersion: fields.deliveryRegistered === true ? fields.attentionRegistrationVersion ?? CHAT_ATTENTION_REGISTRATION_VERSION : 0,
+    notificationMode: fields.notificationMode,
+    registeredEpochId: fields.deliveryRegistered === true ? manifest.epochId : null
+  });
+}
+async function sealOwnChatNotificationPreference(chatPrivateKey, entryId, entry) {
+  const key = notificationPreferenceKey(chatPrivateKey, entryId);
+  try {
+    const manifest = entry?.current?.manifest;
+    if (!manifest)
+      throw new Error("chat notification preference entry required");
+    const preference = normalizeNotificationPreference({
+      v: CHAT_NOTIFICATION_PREFERENCE_VERSION,
+      protocol: CHAT_PROTOCOL_VERSION,
+      notificationMode: entry.notificationMode,
+      registeredEpochId: entry.attentionRegistrationVersion === CHAT_ATTENTION_REGISTRATION_VERSION ? manifest.epochId : null,
+      attentionRegistrationVersion: entry.attentionRegistrationVersion
+    }, entry);
+    const { nonce, ct } = await sealJson(key, preference, notificationPreferenceAad(entryId));
+    return packBodyData(nonce, ct);
+  } finally {
+    cleanBytes(key);
+  }
+}
+async function openOwnChatNotificationPreference(chatPrivateKey, entryId, body, entry) {
+  if (!body)
+    return withNotificationPreference(entry);
+  const key = notificationPreferenceKey(chatPrivateKey, entryId);
+  try {
+    const { nonce, ct } = unpackBodyData(body);
+    const preference = normalizeNotificationPreference(await openJson(key, nonce, ct, notificationPreferenceAad(entryId)), entry);
+    return withNotificationPreference(entry, preference);
+  } finally {
+    cleanBytes(key);
+  }
+}
+async function openOwnChatRecord(chatPrivateKey, entryId, record) {
+  if (!record?.body)
+    throw new Error("chat owner record required");
+  const entry = await openOwnChatEntry(chatPrivateKey, entryId, record.body);
+  return openOwnChatNotificationPreference(chatPrivateKey, entryId, record.notificationBody, entry);
 }
 function normalizeOwnerEpochRecord(value) {
   if (!value || typeof value !== "object" || Array.isArray(value) || value.v !== CHAT_OWNER_EPOCH_ENTRY_VERSION || value.protocol !== CHAT_PROTOCOL_VERSION) {
@@ -10210,6 +10602,7 @@ async function prepareMutation(identity, entryId, current, update) {
     entryId,
     record: {
       body: await sealOwnChatEntry(identity.chatPrivateKey, entryId, entry),
+      notificationBody: await sealOwnChatNotificationPreference(identity.chatPrivateKey, entryId, entry),
       revision: entry.ownerRevision,
       ...Number.isFinite(prepared.tsMs) ? { tsMs: prepared.tsMs } : {},
       ...prepared.touchTs === true ? { touchTs: true } : {}
@@ -10237,7 +10630,7 @@ async function prepareOwnChatMutation(identity, entryId, current, update) {
       if (!record?.body || !Number.isSafeInteger(record.revision) || record.revision < 1) {
         throw new Error("current chat owner record required");
       }
-      const opened = await openOwnChatEntry(identity.chatPrivateKey, entryId, record.body);
+      const opened = await openOwnChatRecord(identity.chatPrivateKey, entryId, record);
       if (opened.ownerRevision !== record.revision) {
         throw new Error("chat owner revision mismatch");
       }
@@ -10273,6 +10666,7 @@ async function retireOwnChatEntry(cloud, identity, entryId, current, fields = {}
         ...latest,
         routes: {},
         deliveryRegistered: false,
+        attentionRegistrationVersion: 0,
         notificationTag: null,
         retirement
       },
@@ -10286,7 +10680,7 @@ async function openOwnChatMutationEntry(identity, entryId, record) {
     return null;
   if (!record?.body || !Number.isSafeInteger(record.revision) || record.revision < 1)
     throw new Error("current chat owner record required");
-  const current = await openOwnChatEntry(identity.chatPrivateKey, entryId, record.body);
+  const current = await openOwnChatRecord(identity.chatPrivateKey, entryId, record);
   if (current.ownerRevision !== record.revision) {
     throw new Error("chat owner revision mismatch");
   }
@@ -10391,6 +10785,166 @@ var MAX_REACTIONS = CHAT_MAX_REACTIONS;
 var HOLD_VISIBLE_KEY = "__holdVisible";
 var SOURCE_GONE_VISIBLE_KEY = "__sourceGoneVisible";
 
+// ../../core/username.js
+var MAX_USERNAME = USERNAME_MAX_CHARS;
+var usernameKeyRegex = /^[a-z0-9]$/i;
+var usernameStripRegex = /[^a-z0-9]/g;
+var usernameRegex = new RegExp(`^[a-z0-9]{1,${MAX_USERNAME}}$`);
+function normalizeUsername(value = "") {
+  return String(value).trim().toLowerCase();
+}
+function cleanUsername(value = "") {
+  return normalizeUsername(value).replace(usernameStripRegex, "").slice(0, MAX_USERNAME);
+}
+function isUsername(value = "") {
+  return usernameRegex.test(value);
+}
+function isUsernameKey(value = "") {
+  return usernameKeyRegex.test(value);
+}
+
+// ../../core/chat/messages/mentions.js
+"use client";
+var CHAT_MENTION_KINDS = Object.freeze({
+  MEMBER: "member",
+  EVERYONE: "everyone"
+});
+var CHAT_PK_RE = /^[0-9a-f]{64}$/u;
+function cleanChatPK(value) {
+  return typeof value === "string" && CHAT_PK_RE.test(value) ? value : "";
+}
+function sourceMention(value, allowBinding = false) {
+  const target = allowBinding && value?.target && typeof value.target === "object" ? value.target : value;
+  if (target?.kind === CHAT_MENTION_KINDS.EVERYONE) {
+    return {
+      start: value?.start,
+      end: value?.end,
+      kind: CHAT_MENTION_KINDS.EVERYONE
+    };
+  }
+  if (target?.kind !== CHAT_MENTION_KINDS.MEMBER)
+    return null;
+  return {
+    start: value?.start,
+    end: value?.end,
+    kind: CHAT_MENTION_KINDS.MEMBER,
+    chatPK: target.chatPK
+  };
+}
+function mentionToken(text, mention) {
+  if (!Number.isSafeInteger(mention?.start) || !Number.isSafeInteger(mention?.end) || mention.start < 0 || mention.end <= mention.start || mention.end > text.length) {
+    return "";
+  }
+  return text.slice(mention.start, mention.end);
+}
+function canonicalMention(text, value, allowBinding = false) {
+  const mention = sourceMention(value, allowBinding);
+  const token = mentionToken(text, mention);
+  if (!token)
+    return null;
+  const before = text[mention.start - 1] || "";
+  const after = text[mention.end] || "";
+  if (before && (before === "@" || isUsernameKey(before)) || after && isUsernameKey(after)) {
+    return null;
+  }
+  if (mention.kind === CHAT_MENTION_KINDS.EVERYONE) {
+    return token === "@everyone" ? mention : null;
+  }
+  if (!cleanChatPK(mention.chatPK) || token[0] !== "@" || !isUsername(token.slice(1))) {
+    return null;
+  }
+  return mention;
+}
+function invalidMentions(message, strict) {
+  if (strict)
+    throw new Error(message);
+  return [];
+}
+function manifestContext(manifest) {
+  const members = Array.isArray(manifest?.members) ? manifest.members : [];
+  const memberChatPKs = new Set(members.map((member) => cleanChatPK(member?.chatPK)).filter(Boolean));
+  return {
+    group: manifest?.lineage === "group" && members.length > 0,
+    memberCount: members.length,
+    memberChatPKs
+  };
+}
+function normalizeMentionList(message, manifest, { strict = false, senderChatPK = "" } = {}) {
+  const raw = message?.mentions;
+  if (raw == null)
+    return [];
+  if (!Array.isArray(raw))
+    return invalidMentions("invalid chat mentions", strict);
+  if (!raw.length)
+    return [];
+  if (message?.t !== "txt" || typeof message?.c !== "string") {
+    return invalidMentions("text message required for mentions", strict);
+  }
+  const context = manifestContext(manifest);
+  if (!context.group)
+    return invalidMentions("group chat required for mentions", strict);
+  const sender = cleanChatPK(senderChatPK || message?.s || message?.from);
+  const mentions = [];
+  const uniqueTargets = new Set;
+  let previousEnd = 0;
+  for (const value of raw) {
+    const mention = canonicalMention(message.c, value);
+    if (!mention || mention.start < previousEnd) {
+      if (strict)
+        throw new Error("invalid chat mention");
+      continue;
+    }
+    if (mention.kind === CHAT_MENTION_KINDS.EVERYONE) {
+      if (context.memberCount > CHAT_ORDINARY_DELIVERY_MAX_MEMBERS) {
+        if (strict)
+          throw new Error("everyone mentions are unavailable in large groups");
+        continue;
+      }
+    } else {
+      if (!context.memberChatPKs.has(mention.chatPK) || mention.chatPK === sender) {
+        if (strict)
+          throw new Error("mention target must be a current chat member");
+        continue;
+      }
+      if (context.memberCount > CHAT_ORDINARY_DELIVERY_MAX_MEMBERS && !uniqueTargets.has(mention.chatPK) && uniqueTargets.size >= CHAT_LARGE_GROUP_MENTION_MAX_TARGETS) {
+        if (strict)
+          throw new Error(`large group mentions support up to ${CHAT_LARGE_GROUP_MENTION_MAX_TARGETS} members`);
+        continue;
+      }
+      uniqueTargets.add(mention.chatPK);
+    }
+    mentions.push(mention);
+    previousEnd = mention.end;
+  }
+  return mentions;
+}
+function normalizeChatMessageMentions(message, manifest, options = {}) {
+  if (!message || typeof message !== "object" || Array.isArray(message))
+    return message;
+  if (message.t !== "txt") {
+    const { mentions: raw, ...rest } = message;
+    if (options.strict && raw != null) {
+      throw new Error("text message required for mentions");
+    }
+    return rest;
+  }
+  return {
+    ...message,
+    mentions: normalizeMentionList(message, manifest, options)
+  };
+}
+function hasChatMessageMentions(message) {
+  return Array.isArray(message?.mentions) && message.mentions.length > 0;
+}
+function chatMessageMentionTargets(message, manifest, options = {}) {
+  const normalized = normalizeChatMessageMentions(message, manifest, { ...options, strict: true });
+  const sender = cleanChatPK(options.senderChatPK || normalized?.s || normalized?.from);
+  const memberChatPKs = [...new Set(normalized.mentions.filter((mention) => mention.kind === CHAT_MENTION_KINDS.MEMBER).map((mention) => mention.chatPK))].sort();
+  const everyone = normalized.mentions.some((mention) => mention.kind === CHAT_MENTION_KINDS.EVERYONE);
+  const recipientChatPKs = everyone ? [...new Set((manifest?.members || []).map((member) => cleanChatPK(member?.chatPK)).filter((chatPK) => chatPK && chatPK !== sender))].sort() : memberChatPKs;
+  return { everyone, memberChatPKs, recipientChatPKs };
+}
+
 // ../../core/chat/messages/text.js
 var DOMAIN_LABEL_PATTERN = "[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?";
 var DOMAIN_TLD_PATTERN = "(?:[a-z]{2,63}|xn--[a-z0-9-]{2,59})";
@@ -12239,7 +12793,6 @@ function getDisplayMessages(messages, selfChatPublicKey, peerChatPublicKey, opti
 
 // ../../core/chat/messages/compact.js
 "use client";
-var pendingCompactKeys = new Set;
 function ownsMessageCompaction(memberChatPKs, chatPK) {
   const members = [...new Set((memberChatPKs || []).filter(Boolean))].sort();
   return !!chatPK && members[0] === chatPK;
@@ -12315,39 +12868,45 @@ function compactKey(chatId, message) {
   const id = cleanText(message?.id);
   return chatId && id ? `${chatId}/${id}` : "";
 }
-function claimMessages(chatId, messages) {
+function claimMessages(maintenance, chatId, messages) {
   const claimed = [];
   for (const message of messages || []) {
     const key = compactKey(chatId, message);
-    if (!key || pendingCompactKeys.has(key))
+    if (!key)
       continue;
-    pendingCompactKeys.add(key);
-    claimed.push(message);
+    const lease = maintenance.claim("message-compaction", key);
+    if (!lease)
+      continue;
+    claimed.push({ lease, message });
   }
   return claimed;
 }
-function releaseMessages(chatId, messages) {
-  for (const message of messages || []) {
-    const key = compactKey(chatId, message);
-    if (key)
-      pendingCompactKeys.delete(key);
-  }
+function releaseMessages(claimed) {
+  for (const item of claimed || [])
+    item.lease.release();
 }
-async function compactMessages({ chatId, messages, deletedKeys, protectedKeys, deleteMessages, scannedKeys, scanComplete }) {
+async function compactMessages({ chatId, maintenance, messages, deletedKeys, protectedKeys, deleteMessages, scannedKeys, scanComplete }) {
   if (!chatId || typeof deleteMessages !== "function")
     return [];
-  const targets = claimMessages(chatId, getCompactMessages(messages, { deletedKeys, protectedKeys, scannedKeys, scanComplete }));
-  if (!targets.length)
+  if (!maintenance?.claim)
+    throw new Error("account message maintenance required");
+  const claimed = claimMessages(maintenance, chatId, getCompactMessages(messages, { deletedKeys, protectedKeys, scannedKeys, scanComplete }));
+  if (!claimed.length)
     return [];
+  const targets = claimed.map((item) => item.message);
   try {
+    for (const item of claimed)
+      item.lease.assertCurrent();
     await deleteMessages(targets);
+    for (const item of claimed)
+      item.lease.assertCurrent();
     if (deletedKeys?.add) {
       for (const message of targets)
         addMessageKeys(deletedKeys, message);
     }
     return targets;
   } finally {
-    releaseMessages(chatId, targets);
+    releaseMessages(claimed);
   }
 }
 
@@ -12879,20 +13438,23 @@ function ownerPreview(senderChatPK, message, messageId, head, tsMs, ttlMs) {
 }
 async function ensureDeliveryRoute(cloud, identity, epochState, entry, shouldPing) {
   if (!shouldPing)
-    return { capability: "", registered: entry?.deliveryRegistered === true };
+    return { capability: "", registered: hasCurrentChatAttentionRegistration(entry) };
   if (!identity.notificationPK) {
     throw new Error("notification identity required");
   }
-  const capability = deriveChatDeliveryCapability(epochState.stateCapability, {
+  const registration = chatDeliveryRegistration(epochState.stateCapability, {
+    attentionSecret: epochState.epochSecret,
     chatId: epochState.manifest.chatId,
     recipientChatPK: identity.chatPK,
-    generation: epochState.manifest.epochVersion
+    generation: epochState.manifest.epochVersion,
+    manifest: epochState.manifest,
+    notificationMode: entry?.notificationMode
   });
-  if (entry?.deliveryRegistered === true) {
-    return { capability, registered: true };
+  if (hasCurrentChatAttentionRegistration(entry)) {
+    return { capability: registration.capability, registered: true };
   }
-  const registered = await cloud.delivery?.register?.(capability).then(() => true, () => false) || false;
-  return { capability: registered ? capability : "", registered };
+  const registered = await cloud.delivery?.register?.(registration).then(() => true, () => false) || false;
+  return { capability: registered ? registration.capability : "", registered };
 }
 function mergedRoutes(entry, options, epochState) {
   const routes = {
@@ -12906,6 +13468,7 @@ function mergedRoutes(entry, options, epochState) {
         ...routes[member.chatPK] || {},
         uid: member.uid,
         notificationPK: member.notificationPK,
+        admissionCapability: routes[member.chatPK]?.admissionCapability || null,
         deliveryCapability: deriveChatDeliveryCapability(epochState.stateCapability, {
           chatId: manifest.chatId,
           recipientChatPK: member.chatPK,
@@ -12924,6 +13487,7 @@ async function makeOwnerEntryMutation(identity, epochState, existing, routes, fi
     ...existing,
     routes,
     deliveryRegistered: fields.deliveryRegistered || existing.deliveryRegistered,
+    attentionRegistrationVersion: fields.deliveryRegistered ? CHAT_ATTENTION_REGISTRATION_VERSION : existing.attentionRegistrationVersion,
     notificationTag: notificationChatTag(epochState.stateCapability, chatId, identity.chatPK),
     ...fields.settings ? {
       current: { ...existing.current, settings: normalizeChatSettingsProjection(fields.settings) }
@@ -12947,12 +13511,13 @@ async function makeOwnerEntryMutation(identity, epochState, existing, routes, fi
       ...current,
       routes: { ...current.routes, ...routes },
       deliveryRegistered: fields.deliveryRegistered || current.deliveryRegistered,
+      attentionRegistrationVersion: fields.deliveryRegistered ? CHAT_ATTENTION_REGISTRATION_VERSION : current.attentionRegistrationVersion,
       notificationTag: notificationChatTag(epochState.stateCapability, chatId, identity.chatPK),
       ...fields.settings ? {
         current: { ...current.current, settings: normalizeChatSettingsProjection(fields.settings) }
       } : {}
     };
-    const unchanged = JSON.stringify(next.routes) === JSON.stringify(current.routes) && next.deliveryRegistered === current.deliveryRegistered && next.notificationTag === current.notificationTag && next.current.settings.digest === current.current.settings.digest;
+    const unchanged = JSON.stringify(next.routes) === JSON.stringify(current.routes) && next.deliveryRegistered === current.deliveryRegistered && next.attentionRegistrationVersion === current.attentionRegistrationVersion && next.notificationTag === current.notificationTag && next.current.settings.digest === current.current.settings.digest;
     return unchanged ? { result: current } : {
       entry: next,
       ...Number.isFinite(fields.tsMs) ? { tsMs: fields.tsMs } : {}
@@ -12992,16 +13557,20 @@ async function makeChatRecipientDeliveries(identity, epochState, routes, message
   if (!fields.shouldPing || fields.deliverRecipients === false)
     return [];
   const capabilities = chatEpochCapabilities(epochState);
-  const targetedRecipient = (fields.recipientChatPKs || []).map(cleanText).find(Boolean) || "";
-  const critical = fields.deliveryClass === "critical";
-  if (!critical && !capabilities.ordinaryDelivery && !targetedRecipient)
+  const currentMemberChatPKs = new Set(epochState.manifest.members.map((member) => member.chatPK));
+  const targetedRecipients = new Set((fields.recipientChatPKs || []).map((value) => cleanText(value).toLowerCase()).filter((chatPK) => chatPK !== identity.chatPK && currentMemberChatPKs.has(chatPK)));
+  const attentionRecipients = new Set((fields.attentionRecipientChatPKs || []).map((value) => cleanText(value).toLowerCase()).filter((chatPK) => chatPK !== identity.chatPK && currentMemberChatPKs.has(chatPK)));
+  const rotation = fields.deliveryClass === "rotation";
+  if (!rotation && !capabilities.ordinaryDelivery && !targetedRecipients.size)
     return [];
   const deliveries = [];
   for (const member of epochState.manifest.members) {
     if (member.chatPK === identity.chatPK)
       continue;
-    if (!critical && !capabilities.ordinaryDelivery && member.chatPK !== targetedRecipient)
+    if (!rotation && !capabilities.ordinaryDelivery && !targetedRecipients.has(member.chatPK))
       continue;
+    const attentionKind = rotation ? CHAT_ATTENTION_KINDS.ROTATION : attentionRecipients.has(member.chatPK) ? CHAT_ATTENTION_KINDS.MENTION : fields.silent === true || !capabilities.ordinaryDelivery ? CHAT_ATTENTION_KINDS.SILENT : CHAT_ATTENTION_KINDS.GENERAL;
+    const attentionPriority = attentionKind === CHAT_ATTENTION_KINDS.ROTATION ? 3 : attentionKind === CHAT_ATTENTION_KINDS.MENTION ? 2 : attentionKind === CHAT_ATTENTION_KINDS.GENERAL ? 1 : 0;
     const route = routes[member.chatPK] || {};
     const descriptor = await sealNotificationDescriptor(member.notificationPK, {
       peerTag: notificationChatTag(epochState.stateCapability, epochState.manifest.chatId, member.chatPK),
@@ -13021,7 +13590,10 @@ async function makeChatRecipientDeliveries(identity, epochState, routes, message
     });
     deliveries.push({
       recipientChatPK: member.chatPK,
-      ...route.deliveryCapability ? { capability: route.deliveryCapability } : { recipientUid: member.uid },
+      ...route.deliveryCapability ? { capability: route.deliveryCapability } : {
+        recipientUid: member.uid,
+        admissionCapability: route.admissionCapability || null
+      },
       deliveryId: deriveChatInboxDeliveryId(epochState.stateCapability, {
         chatId: epochState.manifest.chatId,
         recipientChatPK: member.chatPK,
@@ -13030,7 +13602,14 @@ async function makeChatRecipientDeliveries(identity, epochState, routes, message
       ping,
       descriptor,
       routeTag: notificationRouteTag(descriptor),
-      notify: fields.notify
+      attentionProof: deriveChatAttentionCapability(epochState.epochSecret, {
+        chatId: epochState.manifest.chatId,
+        recipientChatPK: member.chatPK,
+        generation: epochState.manifest.epochVersion,
+        kind: attentionKind
+      }),
+      attentionPriority,
+      notify: attentionKind !== CHAT_ATTENTION_KINDS.SILENT
     });
   }
   return deliveries;
@@ -13048,9 +13627,14 @@ async function prepareMsgRecord(identity, epochState, message, options = {}) {
     }
     const chatRetention = cleanChatRetention(options.retention ?? epochState.settings.values.retention);
     const tsMs = Date.now();
-    const messagePayload = withMessageRetention(message, chatRetention);
+    const retainedMessage = withMessageRetention(message, chatRetention);
+    const messagePayload = normalizeChatMessageMentions(retainedMessage, epochState.manifest, {
+      strict: true,
+      senderChatPK: identity.chatPK
+    });
     const retention = getMessageRetention(messagePayload, chatRetention);
     const actionOp = options.actionOp || actionOpForPayload(messagePayload);
+    const mentionTargets = actionOp === CHAT_ACTION_OPS.CREATE && messagePayload?.t === "txt" ? chatMessageMentionTargets(messagePayload, epochState.manifest, { senderChatPK: identity.chatPK }) : { recipientChatPKs: [] };
     const { head, body } = await sealMsg(epoch, messagePayload, {
       op: actionOp,
       target: options.actionTarget,
@@ -13065,6 +13649,7 @@ async function prepareMsgRecord(identity, epochState, message, options = {}) {
       cid: head.cid,
       record: { lane: epoch.messageLane, head, body, ttlMs },
       message: ownerPreview(identity.chatPK, messagePayload, messageId, head, tsMs, ttlMs),
+      mentionRecipientChatPKs: mentionTargets.recipientChatPKs,
       tsMs
     };
   } finally {
@@ -13097,6 +13682,7 @@ async function sendMsg(cloud, senderChatPK, senderPrivateKey, _receiverChatPK, m
       msgId: messageId,
       record,
       message: sentMessage,
+      mentionRecipientChatPKs,
       tsMs
     } = prepared;
     const updatePreview = options.updatePreview !== false;
@@ -13105,7 +13691,7 @@ async function sendMsg(cloud, senderChatPK, senderPrivateKey, _receiverChatPK, m
     const routes = mergedRoutes(options.ownEntry, options, epochState);
     const preview = updatePreview ? sentMessage : null;
     const settingsProjection = options.settingsProjection ? normalizeChatSettingsProjection(options.settingsProjection) : null;
-    const ownerStateChanged = !options.ownEntry || settingsProjection || shouldPing && routeState.registered && options.ownEntry?.deliveryRegistered !== true;
+    const ownerStateChanged = !options.ownEntry || settingsProjection || shouldPing && routeState.registered && !hasCurrentChatAttentionRegistration(options.ownEntry);
     const ownerMutation = ownerStateChanged ? await makeOwnerEntryMutation(identity, epochState, options.ownEntry, routes, {
       settings: settingsProjection,
       immediate: !!settingsProjection || options.ownerImmediate === true,
@@ -13118,13 +13704,18 @@ async function sendMsg(cloud, senderChatPK, senderPrivateKey, _receiverChatPK, m
       kind: pingKind,
       tsMs
     });
+    const deliveryRecipientChatPKs = [
+      ...options.deliveryRecipientChatPKs || [],
+      ...mentionRecipientChatPKs
+    ];
     const deliveries = await makeChatRecipientDeliveries(identity, epochState, routes, messageId, {
       shouldPing,
       deliverRecipients: options.deliverRecipients !== false,
       kind: pingKind,
       ownDeliveryCapability: routeState.capability,
-      notify: options.notify !== false,
-      recipientChatPKs: options.deliveryRecipientChatPKs,
+      silent: options.notify === false,
+      recipientChatPKs: deliveryRecipientChatPKs,
+      attentionRecipientChatPKs: mentionRecipientChatPKs,
       tsMs
     });
     const write = await cloud.chat.messages.send({
@@ -13746,14 +14337,19 @@ function normalizeDelivery(value) {
     throw new Error("invalid chat membership delivery mode");
   const recipientUid = cleanText(value.recipientUid);
   const capability = cleanText(value.capability).toLowerCase();
+  const admissionCapability = cleanText(value.admissionCapability).toLowerCase();
   if (mode === "critical" && !recipientUid || mode === "established" && !/^[0-9a-f]{64}$/u.test(capability)) {
     throw new Error("invalid chat membership delivery target");
   }
+  if (admissionCapability && !/^[0-9a-f]{64}$/u.test(admissionCapability)) {
+    throw new Error("invalid chat admission capability");
+  }
   return {
     mode,
     recipientUid,
     recipientChatPK: cleanChatHex(value.recipientChatPK, "membership recipient"),
     capability,
+    admissionCapability,
     deliveryId: cleanChatHex(value.deliveryId, "membership delivery id"),
     ping: openPing(value.ping),
     descriptor: openDescriptor(value.descriptor),
@@ -13964,9 +14560,11 @@ function successorManifest(parent, members, epochId) {
     members
   }, { parent, official: true });
 }
-function nextRoutes(entry, manifest, stateCapability) {
+function nextRoutes(entry, manifest, stateCapability, privateMembers = []) {
+  const privateByChatPK = new Map(privateMembers.map((member) => [member.chatPK, member]));
   return Object.fromEntries(manifest.members.map((member) => {
     const current = entry.routes?.[member.chatPK] || {};
+    const privateMember = privateByChatPK.get(member.chatPK) || {};
     return [member.chatPK, {
       uid: member.uid,
       deliveryCapability: deriveChatDeliveryCapability(stateCapability, {
@@ -13975,6 +14573,7 @@ function nextRoutes(entry, manifest, stateCapability) {
         generation: manifest.epochVersion
       }),
       notificationPK: member.notificationPK || current.notificationPK || null,
+      admissionCapability: privateMember.admissionCapability || current.admissionCapability || null,
       generation: manifest.epochVersion
     }];
   }));
@@ -14023,7 +14622,11 @@ async function makeMlsWelcomeDeliveries(identity, nextState2, addedMembers, opti
       senderUid: identity.uid,
       messageId,
       transitionMessageId: nextState2.transitionMessageId,
-      deliveryCapability: null,
+      deliveryCapability: deriveChatDeliveryCapability(nextState2.stateCapability, {
+        chatId: nextState2.manifest.chatId,
+        recipientChatPK: identity.chatPK,
+        generation: nextState2.manifest.epochVersion
+      }),
       notificationPK: identity.notificationPK,
       transitionCommitment: nextState2.transitionCommitment,
       settingsId,
@@ -14044,6 +14647,7 @@ async function makeMlsWelcomeDeliveries(identity, nextState2, addedMembers, opti
       ping,
       descriptor,
       routeTag,
+      admissionCapability: member.admissionCapability || null,
       member
     });
   }
@@ -14058,7 +14662,7 @@ async function makeTransitionWakes(identity, parentState, entry, messageId, tsMs
     shouldPing: true,
     deliverRecipients: true,
     kind: "transition",
-    deliveryClass: "critical",
+    deliveryClass: "rotation",
     ownDeliveryCapability: "",
     notify: true,
     tsMs
@@ -14070,14 +14674,18 @@ async function makeTransitionWakes(identity, parentState, entry, messageId, tsMs
 }
 async function deliverMembershipRecord(cloud, delivery) {
   if (delivery.mode === "established") {
+    if (!/^[0-9a-f]{64}$/u.test(delivery.attentionProof || "")) {
+      throw new Error("chat membership attention proof required");
+    }
     await cloud.inbox.deliver(delivery.capability, delivery.ping, {
+      attentionProof: delivery.attentionProof,
       descriptor: delivery.descriptor,
-      routeTag: delivery.routeTag,
-      notify: true
+      routeTag: delivery.routeTag
     });
     return;
   }
   await pushCriticalInbox(cloud, delivery.recipientUid || delivery.member?.uid, delivery.ping, {
+    admissionCapability: delivery.admissionCapability || null,
     deliveryId: delivery.deliveryId,
     descriptor: delivery.descriptor,
     routeTag: delivery.routeTag,
@@ -14107,6 +14715,46 @@ async function deliverQueuedMembership(cloud, identity, deliveries) {
     deliveredMembers: delivered.map((delivery) => delivery.member).filter(Boolean)
   };
 }
+async function recoverMembershipAttentionSecret(cloud, identity, record, mlsPackage) {
+  const parentEpochVersion = Number(mlsPackage?.head?.epochVersion) - 1;
+  if (!Number.isSafeInteger(parentEpochVersion) || parentEpochVersion < 1) {
+    throw new Error("chat membership parent epoch required");
+  }
+  const entryId = ownChatEntryId(identity.chatPrivateKey, record.chatId);
+  let afterEpoch = null;
+  while (true) {
+    const page = await cloud.user.chats.epochs.list(identity.uid, entryId, {
+      count: 50,
+      ...afterEpoch ? { afterEpoch } : {}
+    });
+    for (const epochRecord of page?.records || []) {
+      const epoch = await openOwnerEpochRecord(identity.chatPrivateKey, entryId, epochRecord.id, epochRecord.body).catch(() => null);
+      if (epoch?.epochVersion === parentEpochVersion && epoch.successorTransitionCommitment === mlsPackage.head.transitionCommitment) {
+        return epoch.epochSecret;
+      }
+    }
+    afterEpoch = page?.nextAfterEpoch ?? null;
+    if (!page?.hasMore || !afterEpoch)
+      break;
+  }
+  throw new Error("chat membership parent attention secret unavailable");
+}
+async function recoverMembershipAttentionProofs(cloud, identity, record, mlsPackage) {
+  if (!record.deliveries.some((delivery) => delivery.mode === "established")) {
+    return record.deliveries;
+  }
+  const attentionSecret = await recoverMembershipAttentionSecret(cloud, identity, record, mlsPackage);
+  const generation = mlsPackage.head.epochVersion - 1;
+  return record.deliveries.map((delivery) => delivery.mode === "established" ? {
+    ...delivery,
+    attentionProof: deriveChatAttentionCapability(attentionSecret, {
+      chatId: record.chatId,
+      recipientChatPK: delivery.recipientChatPK,
+      generation,
+      kind: CHAT_ATTENTION_KINDS.ROTATION
+    })
+  } : delivery);
+}
 async function drainChatMembershipOutbox(cloud, identity, options = {}) {
   const records = await cloud.user.chats.membershipOutbox.list(identity.uid, { count: options.count || 20 });
   const committedPackages = new Map;
@@ -14119,13 +14767,15 @@ async function drainChatMembershipOutbox(cloud, identity, options = {}) {
     }
     const packageKey = `${opened.chatId}:${opened.packageId}:${opened.packageDigest}`;
     if (!committedPackages.has(packageKey)) {
-      const mlsPackage = await cloud.chat.mls.packages.read(opened.chatId, opened.packageId).catch(() => null);
-      committedPackages.set(packageKey, mlsPackage?.digest === opened.packageDigest);
+      const mlsPackage2 = await cloud.chat.mls.packages.read(opened.chatId, opened.packageId).catch(() => null);
+      committedPackages.set(packageKey, mlsPackage2?.digest === opened.packageDigest ? mlsPackage2 : null);
     }
-    if (!committedPackages.get(packageKey))
+    const mlsPackage = committedPackages.get(packageKey);
+    if (!mlsPackage)
       continue;
     try {
-      const results = await Promise.allSettled(opened.deliveries.map((delivery) => deliverMembershipRecord(cloud, delivery)));
+      const deliveries = await recoverMembershipAttentionProofs(cloud, identity, opened, mlsPackage);
+      const results = await Promise.allSettled(deliveries.map((delivery) => deliverMembershipRecord(cloud, delivery)));
       delivered += results.filter((result) => result.status === "fulfilled").length;
       if (results.every((result) => result.status === "fulfilled")) {
         await cloud.user.chats.membershipOutbox.delete(identity.uid, record.id);
@@ -14257,13 +14907,6 @@ async function prepareMembershipTransition(context) {
   });
   if (transitionMessage.msgId !== transitionMessageId)
     throw new Error("chat transition message id mismatch");
-  runtime.ownDeliveryCapability = deriveChatDeliveryCapability(runtime.stateCapability, {
-    chatId: parent.chatId,
-    recipientChatPK: identity.chatPK,
-    generation: next.epochVersion
-  });
-  runtime.stage = "register-delivery";
-  await cloud.delivery.register(runtime.ownDeliveryCapability);
   runtime.stage = "prepare-deliveries";
   const [wakeDeliveries, welcomeDeliveries] = await Promise.all([
     makeTransitionWakes(identity, parentState, entry, transitionMessage.msgId, transitionMessage.tsMs),
@@ -14290,16 +14933,26 @@ async function prepareMembershipTransition(context) {
     if (current.current.manifest.epochId !== parent.epochId || current.current.manifest.epochVersion !== parent.epochVersion) {
       throw new Error("chat owner epoch changed");
     }
+    const notificationMode = normalizeChatNotificationMode(current.notificationMode, next);
     const nextEntry = makeOwnChatEntry(candidateState, {
       ownerRevision: current.ownerRevision,
-      routes: nextRoutes(current, next, runtime.stateCapability),
+      routes: nextRoutes(current, next, runtime.stateCapability, delta.members),
       saved: current.saved,
       startMs: current.startMs,
       deliveryRegistered: true,
+      notificationMode,
       notificationTag: notificationChatTag(runtime.stateCapability, parent.chatId, identity.chatPK)
     });
     return {
       entry: nextEntry,
+      deliveryRegistration: chatDeliveryRegistration(runtime.stateCapability, {
+        attentionSecret: runtime.epochSecret,
+        chatId: parent.chatId,
+        recipientChatPK: identity.chatPK,
+        generation: next.epochVersion,
+        manifest: next,
+        notificationMode
+      }),
       ...Number.isFinite(fields.ownerTsMs) ? { tsMs: fields.ownerTsMs } : { touchTs: true },
       epochs: [{ id: historyId, record: historyRecord }],
       mlsWrites: [{ id: ownerMlsState.stateId, value: ownerMlsState.value }],
@@ -14442,7 +15095,6 @@ async function transitionChatEpoch(cloud, identityValue, entry, fields = {}) {
     epochSecret: null,
     metrics: {},
     nextSnapshot: null,
-    ownDeliveryCapability: "",
     parentSnapshot: null,
     stage: "read-owner-mls",
     stateCapability: null
@@ -14470,9 +15122,6 @@ async function transitionChatEpoch(cloud, identityValue, entry, fields = {}) {
     });
     throw error;
   } finally {
-    if (runtime.ownDeliveryCapability && !runtime.committed) {
-      await cloud.delivery.revoke(runtime.ownDeliveryCapability).catch(() => false);
-    }
     cleanBytes(runtime.parentSnapshot, runtime.nextSnapshot, runtime.epochSecret, runtime.stateCapability);
   }
 }
@@ -14865,7 +15514,7 @@ function sortedUniqueValues(items) {
 
 // ../../core/chat/chats.js
 "use client";
-var HEX_32_RE3 = /^[0-9a-f]{32}$/i;
+var HEX_32_RE4 = /^[0-9a-f]{32}$/i;
 var HEX_64_RE = /^[0-9a-f]{64}$/i;
 function sameSigningKeys(left, right) {
   if (left === right)
@@ -14889,7 +15538,7 @@ function sameMembers(left, right) {
 function sameChatShape(a, b) {
   if (!a || !b)
     return a === b;
-  return a.id === b.id && a.protocol === b.protocol && a.entryId === b.entryId && a.epochId === b.epochId && a.epochVersion === b.epochVersion && a.lineage === b.lineage && a.memberCount === b.memberCount && sameMembers(a.members, b.members) && a.peerChatPK === b.peerChatPK && a.peerUid === b.peerUid && sameSigningKeys(a.signingKeysByChatKey, b.signingKeysByChatKey) && a.signerShared === b.signerShared && a.deliveryRegistered === b.deliveryRegistered && a.peerDeliveryCapability === b.peerDeliveryCapability && a.peerNotificationPK === b.peerNotificationPK && a.notificationTag === b.notificationTag && a.ts === b.ts && a.startMs === b.startMs && a.readMs === b.readMs && a.inboxMessageId === b.inboxMessageId && a.inboxMessageAt === b.inboxMessageAt && a.inboxMessage === b.inboxMessage && a.unseen === b.unseen && a.settings?.retention === b.settings?.retention && a.settings?.title === b.settings?.title && a.settings?.avatarRef === b.settings?.avatarRef && a.membershipRemoved === true === (b.membershipRemoved === true) && sameChatPreview(a.preview, b.preview);
+  return a.id === b.id && a.protocol === b.protocol && a.entryId === b.entryId && a.epochId === b.epochId && a.epochVersion === b.epochVersion && a.lineage === b.lineage && a.memberCount === b.memberCount && sameMembers(a.members, b.members) && a.peerChatPK === b.peerChatPK && a.peerUid === b.peerUid && sameSigningKeys(a.signingKeysByChatKey, b.signingKeysByChatKey) && a.signerShared === b.signerShared && a.deliveryRegistered === b.deliveryRegistered && a.attentionRegistrationVersion === b.attentionRegistrationVersion && a.notificationMode === b.notificationMode && a.peerDeliveryCapability === b.peerDeliveryCapability && a.peerNotificationPK === b.peerNotificationPK && a.notificationTag === b.notificationTag && a.ts === b.ts && a.startMs === b.startMs && a.readMs === b.readMs && a.inboxMessageId === b.inboxMessageId && a.inboxMessageAt === b.inboxMessageAt && a.inboxMessage === b.inboxMessage && a.unseen === b.unseen && a.settings?.retention === b.settings?.retention && a.settings?.title === b.settings?.title && a.settings?.avatarRef === b.settings?.avatarRef && a.membershipRemoved === true === (b.membershipRemoved === true) && sameChatPreview(a.preview, b.preview);
 }
 function sameChats(prev, next) {
   if (prev.length !== next.length)
@@ -14963,7 +15612,7 @@ function chatVersionKey(chat) {
   return "";
 }
 function isHex32(value) {
-  return HEX_32_RE3.test(cleanText(value));
+  return HEX_32_RE4.test(cleanText(value));
 }
 function isHex64(value) {
   return HEX_64_RE.test(cleanText(value));
@@ -16019,7 +16668,9 @@ function serializeChat(chat) {
     ts: timestampMs(chat.ts, null, { positive: true }) || 0,
     lastUsedAt: Date.now(),
     unseen: !!chat.unseen,
-    membershipRemoved: chat.membershipRemoved === true
+    membershipRemoved: chat.membershipRemoved === true,
+    attentionRegistrationVersion: Number(chat.attentionRegistrationVersion) || 0,
+    notificationMode: chat.notificationMode || null
   };
 }
 function reviveChat(chat) {
@@ -16050,7 +16701,9 @@ function reviveChat(chat) {
     ts: timestampMs(chat.ts, null, { positive: true }) || 0,
     lastUsedAt: timestampMs(chat.lastUsedAt, null, { positive: true }) || 0,
     unseen: !!chat.unseen,
-    membershipRemoved: chat.membershipRemoved === true
+    membershipRemoved: chat.membershipRemoved === true,
+    attentionRegistrationVersion: Number(chat.attentionRegistrationVersion) || 0,
+    notificationMode: chat.notificationMode || null
   };
 }
 function isReadableCachedChat(chat) {
@@ -17453,7 +18106,7 @@ function createChatLive({
       return sendSnapshot(entry);
     }
     if (!nextCompositionId) {
-      if (!entry.typing)
+      if (!entry.typing && !entry.compositionId)
         return false;
       entry.typing = false;
       entry.compositionId = "";
@@ -18056,7 +18709,10 @@ ${cid}` : "";
       }
       if (adopt && !adoptedLocalMediaRef.current.has(mediaKey)) {
         adoptedLocalMediaRef.current.add(mediaKey);
-        adoptLocalMessageMedia?.(message, local, { chatId });
+        adoptLocalMessageMedia?.(message, local, {
+          chatId,
+          peerChatPK: local.peerChatPK
+        });
       }
     }
     if (changed) {
@@ -18277,6 +18933,9 @@ ${cid}` : "";
     const sendOptions = mergeSendOptions(sendOptionsForPeer(peerChatPK), options);
     const nextMessage = withMessageRetention(message, sendOptions.retention);
     if (isLongTxt(nextMessage)) {
+      if (hasChatMessageMentions(nextMessage)) {
+        throw new Error("messages with mentions must fit in a text message");
+      }
       const cid = makeSendCid(nextMessage);
       const attachment = makeTxtFileAttachment(nextMessage);
       const localMessage = makeLongTxtLocalMessage(chatPK, cid, attachment, nextMessage);
@@ -19336,9 +19995,12 @@ function normalizeDecryptedMsg(msgData, message, epoch, readContext) {
   if (!message || typeof message !== "object")
     return null;
   const epochSigningKeysVersion = signingKeysFingerprint(readContext?.signingKeysByChatKey);
+  const content = normalizeChatMessageMentions(message, epoch?.manifest, {
+    senderChatPK: message.s || message.from
+  });
   const normalized = {
-    ...message,
-    id: message.id || msgData?.id || null,
+    ...content,
+    id: content.id || msgData?.id || null,
     ts: msgData?.ts ?? null,
     ttl: msgData?.ttl ?? null,
     ...decryptedEpochFields(epoch),
@@ -20145,11 +20807,171 @@ async function readMsg({ cloud, messageId, options = {} }) {
     deletedKeys: []
   };
 }
+// ../../core/account/scope.js
+var ACCOUNT_SCOPE_STALE_CODE = "account-scope/stale";
+var PROFILE_ID_RE = /^[0-9a-f]{32}$/;
+var ACCOUNT_SCOPE_CAPABILITIES = new WeakSet;
+function requireGeneration(value) {
+  const generation = Number(value);
+  if (!Number.isSafeInteger(generation) || generation < 0) {
+    throw new Error("account scope generation required");
+  }
+  return generation;
+}
+function requireProfileId(value) {
+  const profileId = lowerText(value);
+  if (!PROFILE_ID_RE.test(profileId))
+    throw new Error("account scope profile id required");
+  return profileId;
+}
+function requireText(value, label) {
+  const text = cleanText(value);
+  if (!text)
+    throw new Error(`${label} required`);
+  return text;
+}
+function staleAccountScopeError(scope = null) {
+  const error = new Error("account scope is no longer active");
+  error.code = ACCOUNT_SCOPE_STALE_CODE;
+  error.profileId = scope?.profileId || null;
+  error.generation = Number.isSafeInteger(scope?.generation) ? scope.generation : null;
+  return error;
+}
+function createAccountScope({
+  environment,
+  generation,
+  isCurrent,
+  profileId,
+  uid
+} = {}) {
+  if (typeof isCurrent !== "function")
+    throw new Error("account scope current-state port required");
+  const normalizedEnvironment = lowerText(requireText(environment, "account scope environment"));
+  const normalizedGeneration = requireGeneration(generation);
+  const normalizedProfileId = requireProfileId(profileId);
+  const normalizedUid = requireText(uid, "account scope uid");
+  const accountOwnerKey = `${normalizedEnvironment}:${normalizedProfileId}:${normalizedUid}`;
+  const scope = {
+    accountOwnerKey,
+    environment: normalizedEnvironment,
+    generation: normalizedGeneration,
+    key: `${accountOwnerKey}:${normalizedGeneration}`,
+    profileId: normalizedProfileId,
+    uid: normalizedUid,
+    isCurrent: () => isCurrent() === true,
+    assertCurrent() {
+      if (!scope.isCurrent())
+        throw staleAccountScopeError(scope);
+      return scope;
+    }
+  };
+  ACCOUNT_SCOPE_CAPABILITIES.add(scope);
+  return Object.freeze(scope);
+}
+function isAccountScope(value) {
+  return !!value && typeof value === "object" && ACCOUNT_SCOPE_CAPABILITIES.has(value);
+}
+
+// ../../core/chat/messages/maintenance.js
+var STALE_MAINTENANCE_CODE = "chat-maintenance/stale";
+function staleError() {
+  const error = new Error("chat maintenance owner is no longer current");
+  error.code = STALE_MAINTENANCE_CODE;
+  return error;
+}
+function cleanKey(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function isStaleMessageMaintenance(error) {
+  return error?.code === STALE_MAINTENANCE_CODE;
+}
+function createAccountMessageMaintenance({ isAccountCurrent = null } = {}) {
+  const claims = new Set;
+  const tasks = new Set;
+  let generation = 0;
+  let open = true;
+  let scope = null;
+  const accountCurrent = () => scope?.isCurrent?.() === true || !scope && (typeof isAccountCurrent !== "function" || isAccountCurrent() === true);
+  const isCurrent = (expectedGeneration = generation) => open && expectedGeneration === generation && accountCurrent();
+  const assertCurrent = (expectedGeneration = generation) => {
+    if (!isCurrent(expectedGeneration))
+      throw staleError();
+    return true;
+  };
+  const owner = {
+    assertCurrent,
+    isCurrent,
+    bindScope(nextScope) {
+      if (!isAccountScope(nextScope)) {
+        throw new Error("account message maintenance scope required");
+      }
+      if (scope && scope !== nextScope) {
+        throw new Error("account message maintenance scope already bound");
+      }
+      scope = nextScope;
+      return scope;
+    },
+    open() {
+      if (open)
+        return generation;
+      generation += 1;
+      open = true;
+      claims.clear();
+      return generation;
+    },
+    claim(kind, value) {
+      const type = cleanKey(kind);
+      const key = cleanKey(value);
+      if (!type || !key)
+        throw new Error("chat maintenance claim key required");
+      assertCurrent();
+      const claimKey = `${type}:${key}`;
+      if (claims.has(claimKey))
+        return null;
+      const claimGeneration = generation;
+      claims.add(claimKey);
+      let released = false;
+      return Object.freeze({
+        assertCurrent: () => {
+          if (released || !claims.has(claimKey))
+            throw staleError();
+          return assertCurrent(claimGeneration);
+        },
+        isCurrent: () => !released && claims.has(claimKey) && isCurrent(claimGeneration),
+        release() {
+          if (released)
+            return false;
+          released = true;
+          claims.delete(claimKey);
+          return true;
+        }
+      });
+    },
+    track(value) {
+      const taskGeneration = generation;
+      assertCurrent(taskGeneration);
+      const task = Promise.resolve(value).finally(() => tasks.delete(task));
+      tasks.add(task);
+      return task;
+    },
+    close() {
+      if (open) {
+        open = false;
+        generation += 1;
+        claims.clear();
+      }
+      return Promise.allSettled([...tasks]);
+    },
+    drain: () => Promise.allSettled([...tasks])
+  };
+  return Object.freeze(owner);
+}
+
 // ../../core/chat/messages/batches/cleanup.js
 function isDenied(error) {
   return error?.code === "permission-denied";
 }
-function runMessageBatchCleanup({ entry, options = {}, chatBanned, isActive, chatPK, localCache, deleteMessageDocs, diag, getCurrentEntry, notify }) {
+function runMessageBatchCleanup({ entry, options = {}, chatBanned, isActive, chatPK, localCache, maintenance, deleteMessageDocs, diag, getCurrentEntry, notify }) {
   if (chatBanned || !isActive || !ownsMessageCompaction(entry?.memberChatPKs, chatPK) || !entry?.chatId || !entry.peerChatPK || !entry.ready || entry.exists === false || !entry.messages?.length || typeof deleteMessageDocs !== "function") {
     return null;
   }
@@ -20161,18 +20983,25 @@ function runMessageBatchCleanup({ entry, options = {}, chatBanned, isActive, cha
   const peerChatPK = entry.peerChatPK;
   const generation = entry.generation;
   const scheduledAt = Date.now();
+  if (!maintenance?.claim)
+    throw new Error("account message maintenance required");
+  const lease = maintenance.claim("batch-cleanup", `${chatId}:${generation}`);
+  if (!lease)
+    return null;
   markDiag(diag, "chat.message.cleanup.schedule", {
     chatId,
     compactControls,
     idle: options.idle !== false,
     messages: entry.messages?.length || 0
   });
-  return Promise.resolve().then(async () => {
+  const operation = Promise.resolve().then(async () => {
+    lease.assertCurrent();
     if (options.idle !== false) {
       await waitForIdle({
         timeout: CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS,
         delay: CHAT_BATCH_CLEANUP_IDLE_DELAY_MS
       });
+      lease.assertCurrent();
     }
     let current = getCurrentEntry?.(chatId);
     if (current !== entry || current.generation !== generation || current.route) {
@@ -20195,8 +21024,10 @@ function runMessageBatchCleanup({ entry, options = {}, chatBanned, isActive, cha
       return;
     }
     if (compactControls) {
+      lease.assertCurrent();
       const compacted = await compactMessages({
         chatId,
+        maintenance,
         messages: current.messages.slice(),
         deletedKeys,
         protectedKeys: compactProtectedKeys,
@@ -20207,6 +21038,7 @@ function runMessageBatchCleanup({ entry, options = {}, chatBanned, isActive, cha
       if (compacted.length) {
         dropped.push(...compacted);
       }
+      lease.assertCurrent();
     }
     if (dropped.length) {
       const cacheStartedAt = Date.now();
@@ -20219,7 +21051,12 @@ function runMessageBatchCleanup({ entry, options = {}, chatBanned, isActive, cha
         startMs: entry.startMs,
         messages: dropped,
         mode: "confirmed"
+      }).then((result) => {
+        lease.assertCurrent();
+        return result;
       }).catch((error) => {
+        if (isStaleMessageMaintenance(error))
+          throw error;
         markError(diag, "chat.message.cleanup.cache", cacheStartedAt, error, {
           droppedCount: dropped.length
         });
@@ -20241,14 +21078,16 @@ function runMessageBatchCleanup({ entry, options = {}, chatBanned, isActive, cha
     if (current !== entry || current.generation !== generation || current.route || !dropped.length) {
       return;
     }
+    lease.assertCurrent();
     notify(current);
   }).catch((error) => {
-    if (!isDenied(error)) {
+    if (!isDenied(error) && !isStaleMessageMaintenance(error)) {
       markError(diag, "chat.message.cleanup", Date.now(), error, {
         compactControls
       });
     }
-  });
+  }).finally(() => lease.release());
+  return maintenance.track(operation);
 }
 
 // ../../core/chat/messages/epochhistory.js
@@ -20814,6 +21653,7 @@ function runBatchCleanup(owner, entry, options = {}) {
     isActive: sources.isActive,
     chatPK: sources.chatPK,
     localCache: sources.localCache,
+    maintenance: sources.maintenance,
     deleteMessageDocs: sources.deleteMessageDocs,
     diag: sources.diag,
     getCurrentEntry: (chatId) => owner.batches.get(chatId),
@@ -21773,6 +22613,9 @@ function messageBatchSources(input = {}) {
 }
 function createChatMessageBatches(input) {
   let sources = messageBatchSources(input);
+  if (!sources.maintenance?.claim) {
+    throw new Error("message batches require account maintenance");
+  }
   let warming = null;
   const routeMemory = createRouteMemory(MESSAGE_VIEW_CACHE_SIZE);
   const collection = createMessageBatchCollection({
@@ -21793,7 +22636,11 @@ function createChatMessageBatches(input) {
     collection.clear();
   };
   const setSources = (next) => {
-    sources = messageBatchSources(next);
+    const nextSources = messageBatchSources(next);
+    if (nextSources.maintenance !== sources.maintenance) {
+      throw new Error("message batch maintenance owner cannot change");
+    }
+    sources = nextSources;
     warming.sync();
   };
   return Object.freeze({
@@ -22080,7 +22927,7 @@ function epochMessageReadContext(epochState) {
 async function readEntry(cloud, uid, chatPrivateKey, chatId) {
   const entryId = ownChatEntryId(chatPrivateKey, chatId);
   const record = await cloud.user.chats.read(uid, entryId);
-  const entry = record ? await openOwnChatEntry(chatPrivateKey, entryId, record.body).catch(() => null) : null;
+  const entry = record ? await openOwnChatRecord(chatPrivateKey, entryId, record).catch(() => null) : null;
   if (entry && entry.ownerRevision !== record?.revision)
     throw new Error("chat owner revision mismatch");
   return { entryId, entry };
@@ -22120,6 +22967,50 @@ function cachedInboxRead(cache, key, read) {
 function hasBlockedMembers(manifest, blockedUids) {
   return blockedUids instanceof Set && blockedUids.size > 0 && manifest.members.some((member) => blockedUids.has(member.uid));
 }
+function publicIncomingChatMember(member) {
+  return Object.freeze({
+    uid: cleanText(member?.uid),
+    chatPK: cleanText(member?.chatPK),
+    chatSigningPK: cleanText(member?.chatSigningPK),
+    notificationPK: cleanText(member?.notificationPK)
+  });
+}
+function incomingChatAdmissionContext(context, epochState) {
+  const sender = context.senderProfile || {};
+  return Object.freeze({
+    sender: Object.freeze({
+      uid: cleanText(sender.uid),
+      username: cleanText(sender.username),
+      chatPK: cleanText(sender.chatPK),
+      chatSigningPK: cleanText(sender.chatSigningPK),
+      notificationPK: cleanText(sender.notificationPK)
+    }),
+    chat: Object.freeze({
+      id: cleanText(epochState?.manifest?.chatId),
+      lineage: cleanText(epochState?.manifest?.lineage),
+      members: Object.freeze((epochState?.manifest?.members || []).map(publicIncomingChatMember))
+    }),
+    self: Object.freeze({
+      uid: cleanText(context.identity?.uid),
+      chatPK: cleanText(context.identity?.chatPK)
+    })
+  });
+}
+async function decideIncomingChat(context, epochState) {
+  const resolution = context.options.chatRequestResolutions?.get?.(context.options.requestToken);
+  if (resolution?.decision)
+    return normalizeChatAdmissionDecision(resolution.decision);
+  const policyDecision = incomingChatAdmissionDecision(context.identity.chatPrivateKey, context.identity.chatPK, context.senderProfile, context.options.chatAdmission, epochState?.manifest?.lineage);
+  if (typeof context.options.incomingChatDecision !== "function")
+    return policyDecision;
+  try {
+    const harnessDecision = normalizeChatAdmissionDecision(await context.options.incomingChatDecision(incomingChatAdmissionContext(context, epochState)));
+    return strictestChatAdmissionDecision(policyDecision, harnessDecision);
+  } catch {
+    markDiag(context.options.diag, "chat.inbox.admission.failed", {});
+    return CHAT_ADMISSION_DECISIONS.REJECT;
+  }
+}
 function inboxLeaseError() {
   const error = new Error("chat inbox session changed");
   error.code = "chat/session-stale";
@@ -22329,27 +23220,16 @@ function routesForManifest(entry, epochState) {
     }];
   }));
 }
-function epochDeliveryCapability(identity, epochState) {
-  return deriveChatDeliveryCapability(epochState.stateCapability, {
+function epochDeliveryRegistration(identity, epochState, notificationMode) {
+  return chatDeliveryRegistration(epochState.stateCapability, {
+    attentionSecret: epochState.epochSecret,
     chatId: epochState.manifest.chatId,
     recipientChatPK: identity.chatPK,
-    generation: epochState.manifest.epochVersion
+    generation: epochState.manifest.epochVersion,
+    manifest: epochState.manifest,
+    notificationMode
   });
 }
-async function registerEpochDelivery(cloud, identity, epochState, previousState, wasRegistered, options) {
-  const capability = epochDeliveryCapability(identity, epochState);
-  assertInboxLease(options);
-  await cloud.delivery.register(capability);
-  if (previousState && wasRegistered) {
-    const oldCapability = deriveChatDeliveryCapability(previousState.stateCapability, {
-      chatId: previousState.manifest.chatId,
-      recipientChatPK: identity.chatPK,
-      generation: previousState.manifest.epochVersion
-    });
-    await cloud.delivery.revoke(oldCapability).catch(() => false);
-  }
-  return true;
-}
 async function readPingMessage(cloud, payload, epochState) {
   const messageId = cleanText(payload.messageId);
   if (!messageId)
@@ -22436,7 +23316,7 @@ function sameEntryEpoch(left, right) {
   return left?.current?.manifest?.epochId === right?.current?.manifest?.epochId && left?.current?.settings?.digest === right?.current?.settings?.digest;
 }
 function sameEntryRegistration(left, right) {
-  return left?.deliveryRegistered === right?.deliveryRegistered && left?.notificationTag === right?.notificationTag;
+  return left?.deliveryRegistered === right?.deliveryRegistered && left?.attentionRegistrationVersion === right?.attentionRegistrationVersion && left?.notificationMode === right?.notificationMode && left?.notificationTag === right?.notificationTag;
 }
 function sameEntryRetirement(left, right) {
   return left?.retirement?.kind === right?.retirement?.kind && left?.retirement?.epochVersion === right?.retirement?.epochVersion;
@@ -22468,6 +23348,8 @@ function projectOwnChatEntry(entry, entryId, userChatPK, ts, activity = {}) {
     settings,
     routes: entry.routes,
     deliveryRegistered: entry.deliveryRegistered === true,
+    attentionRegistrationVersion: entry.attentionRegistrationVersion,
+    notificationMode: entry.notificationMode,
     notificationTag: entry.notificationTag,
     epochState: entry.current,
     ownEntry: entry,
@@ -22586,14 +23468,22 @@ async function verifyOpenedPingEpoch(context) {
   if (epochState.manifest.epochId !== payload.epochId || epochState.manifest.epochVersion !== payload.epochVersion) {
     throw new Error("ping epoch mismatch");
   }
+  context.epochState = epochState;
   if (hasBlockedMembers(epochState.manifest, options.blockedUids)) {
     if (context.entry) {
       await unlinkBlockedChat(cloud, uid, identity, context.entry, options);
       return "deleted";
     }
-    throw new Error("blocked chat member");
+    return "blocked";
+  }
+  const incomingMembership = payload.kind === "welcome" && (!context.entry || context.restoringMembership);
+  if (incomingMembership) {
+    const decision = await decideIncomingChat(context, epochState);
+    if (decision === CHAT_ADMISSION_DECISIONS.REJECT)
+      return "rejected";
+    if (decision === CHAT_ADMISSION_DECISIONS.REQUEST)
+      return "request";
   }
-  context.epochState = epochState;
   return null;
 }
 function startOpenedWelcomeHydration(context) {
@@ -22601,7 +23491,6 @@ function startOpenedWelcomeHydration(context) {
   if (!membershipWelcome)
     return;
   context.prefetchedMessage = captureAsync(readPingMessage(context.cloud, context.payload, context.epochState));
-  context.deliveryRegistration = captureAsync(!context.entry || context.entry?.deliveryRegistered === true ? true : registerEpochDelivery(context.cloud, context.identity, context.epochState, context.entry?.current || null, context.entry?.deliveryRegistered === true, context.options));
 }
 async function applyOpenedPingMessage(context) {
   const { cloud, identity, options, payload, uid } = context;
@@ -22647,19 +23536,12 @@ async function applyOpenedPingMessage(context) {
   return null;
 }
 async function prepareOpenedPingOwner(context) {
-  const { cloud, identity, payload, senderProfile } = context;
+  const { identity, payload, senderProfile } = context;
   const routes = withSenderRoute(context.entry, payload, senderProfile, context.epochState);
   const nowMs2 = timestampMs(payload.ts, Date.now()) ?? Date.now();
   const membershipWelcome = (!context.entry || context.restoringMembership) && payload.kind === "welcome";
-  const initialDeliveryCapability = !context.entry && membershipWelcome ? epochDeliveryCapability(identity, context.epochState) : null;
-  let deliveryRegistered = context.entry?.deliveryRegistered === true;
-  if (initialDeliveryCapability)
-    deliveryRegistered = true;
-  if (!deliveryRegistered && context.deliveryRegistration) {
-    deliveryRegistered = await unwrapAsync(context.deliveryRegistration);
-  }
-  if (!deliveryRegistered)
-    deliveryRegistered = await registerEpochDelivery(cloud, identity, context.epochState, null, context.entry?.deliveryRegistered === true, context.options);
+  const initialDeliveryRegistration = membershipWelcome ? epochDeliveryRegistration(identity, context.epochState) : null;
+  const deliveryRegistered = true;
   const nextEntry = context.entry ? {
     ...context.entry,
     current: {
@@ -22673,6 +23555,8 @@ async function prepareOpenedPingOwner(context) {
     },
     routes,
     deliveryRegistered,
+    attentionRegistrationVersion: CHAT_ATTENTION_REGISTRATION_VERSION,
+    notificationMode: normalizeChatNotificationMode(context.entry.notificationMode, context.epochState.manifest),
     notificationTag: notificationChatTag(context.epochState.stateCapability, payload.chatId, identity.chatPK),
     retirement: null
   } : makeOwnChatEntry(context.epochState, {
@@ -22683,7 +23567,7 @@ async function prepareOpenedPingOwner(context) {
   });
   const welcomeMlsState = membershipWelcome && context.epochState.mlsSnapshot ? await prepareOwnerChatMlsSnapshot(identity, context.entryId, context.epochState, context.epochState.mlsSnapshot) : null;
   Object.assign(context, {
-    initialDeliveryCapability,
+    initialDeliveryRegistration,
     membershipWelcome,
     nextEntry,
     nowMs: nowMs2,
@@ -22697,7 +23581,7 @@ async function commitOpenedPingOwner(context) {
   const {
     cloud,
     identity,
-    initialDeliveryCapability,
+    initialDeliveryRegistration,
     membershipWelcome,
     nextEntry,
     nowMs: nowMs2,
@@ -22711,7 +23595,7 @@ async function commitOpenedPingOwner(context) {
       return {
         entry: nextEntry,
         tsMs: nowMs2,
-        deliveryRegistration: initialDeliveryCapability,
+        deliveryRegistration: initialDeliveryRegistration,
         ...welcomeMlsState ? { mlsWrites: [{ id: welcomeMlsState.stateId, value: welcomeMlsState.value }] } : {}
       };
     }
@@ -22726,13 +23610,18 @@ async function commitOpenedPingOwner(context) {
       current: nextEntry.current,
       routes: withSenderRoute(current, payload, senderProfile, context.epochState),
       deliveryRegistered: current.deliveryRegistered || nextEntry.deliveryRegistered,
+      attentionRegistrationVersion: CHAT_ATTENTION_REGISTRATION_VERSION,
+      notificationMode: normalizeChatNotificationMode(current.notificationMode, context.epochState.manifest),
       notificationTag: nextEntry.notificationTag,
       retirement: membershipWelcome ? null : current.retirement
     };
     if (sameStableEntry(current, candidate) && !welcomeMlsState)
       return { result: current };
+    const registrationMatchesEpoch = current.current.manifest.epochId === context.epochState.manifest.epochId && hasCurrentChatAttentionRegistration(current);
+    const deliveryRegistration = registrationMatchesEpoch ? null : epochDeliveryRegistration(identity, context.epochState, candidate.notificationMode);
     return {
       entry: candidate,
+      deliveryRegistration,
       ...membershipWelcome ? { tsMs: nowMs2 } : {},
       ...welcomeMlsState ? { mlsWrites: [{ id: welcomeMlsState.stateId, value: welcomeMlsState.value }] } : {}
     };
@@ -22744,10 +23633,18 @@ async function commitOpenedPingOwner(context) {
 }
 async function cleanupOpenedPing(context) {
   const { cloud, identity, options } = context;
-  if (!context.membershipWelcome || !context.epochState.mlsSnapshot || context.epochState.mlsKeyPackageLastResort)
+  const membershipWelcome = context.payload.kind === "welcome" && (!context.entry || context.restoringMembership);
+  if (!membershipWelcome || !context.epochState?.mlsSnapshot || context.epochState.mlsKeyPackageLastResort)
     return;
+  const keyPackageId = cleanText(context.epochState.mlsKeyPackageId);
+  if (!keyPackageId)
+    return;
+  const consumed = options.consumedMlsKeyPackageIds;
+  if (consumed?.has(keyPackageId))
+    return;
+  consumed?.add(keyPackageId);
   assertInboxLease(options);
-  await cloud.user.mls.keyPackages.deleteState(identity.uid, context.epochState.mlsKeyPackageId).catch(() => false);
+  await cloud.user.mls.keyPackages.deleteState(identity.uid, keyPackageId).catch(() => false);
   options.onMlsKeyPackageConsumed?.();
 }
 function openedPingProjection(context, entry) {
@@ -22814,9 +23711,13 @@ async function persistOpenedPingOwner(context) {
   });
 }
 async function settleOpenedPing(prepared, onAuthoritative) {
-  if (prepared.result)
-    return prepared.result;
   const { context } = prepared;
+  if (prepared.result === "request")
+    return "request";
+  if (prepared.result) {
+    await cleanupOpenedPing(context);
+    return prepared.result;
+  }
   startOpenedWelcomeHydration(context);
   const createsMembership = !context.entry && context.payload.kind === "welcome";
   const ownerPersistence = createsMembership ? captureAsync(persistOpenedPingOwner(context)) : null;
@@ -22841,6 +23742,15 @@ async function settleOpenedPing(prepared, onAuthoritative) {
   });
   return true;
 }
+async function hydrateOpenedChatRequest(context) {
+  const { message, record } = await readPingMessage(context.cloud, context.payload, context.epochState);
+  if (!message || !record || !cleanText(context.payload.messageId)) {
+    throw new Error("chat request message required");
+  }
+  context.message = message;
+  context.record = record;
+  context.preview = nextPreview(null, record, message, context.payload);
+}
 function senderProfilePromise(cache, cloud, payload) {
   const key = `${cleanText(payload?.senderUid)}:${cleanText(payload?.senderChatPK)}`;
   return cachedInboxRead(cache, key, () => resolveSenderProfile(cloud, payload));
@@ -22913,13 +23823,15 @@ function welcomeAnnouncementFromPreparedPing(authenticated, prepared, document)
     members: manifest.members,
     settings,
     messageId: payload.messageId || null,
+    messageRequest: prepared?.opened?.result === "request",
+    preview: prepared?.opened?.context?.preview || null,
     at: ts
   };
 }
 function announcePreparedWelcome(context, authenticated, prepared, document, startedAt) {
   const { blockedUids, options, state } = context;
   const payload = authenticated?.ping?.payload;
-  if (payload?.kind !== "welcome" || state.currentChats.some((chat) => chat?.id === payload.chatId) || blockedUids.has(payload.senderUid)) {
+  if (prepared?.opened?.result && prepared.opened.result !== "request" || payload?.kind !== "welcome" || state.currentChats.some((chat) => chat?.id === payload.chatId) || blockedUids.has(payload.senderUid)) {
     return () => {};
   }
   markDiag(options.diag, "chat.inbox.chat.announced", {
@@ -23071,12 +23983,11 @@ async function commitRemovedEpochTransition(context) {
   return { removed: true, chatId: parent.chatId, entry: retiredEntry };
 }
 async function prepareReceivedEpochOwner(context) {
-  const { cloud, entry, identity, options, parent } = context;
+  const { entry, identity, options, parent } = context;
   if (hasBlockedMembers(context.epochState.manifest, options.blockedUids)) {
-    context.terminal = await unlinkBlockedChat(cloud, context.uid, identity, entry, options);
+    context.terminal = await unlinkBlockedChat(context.cloud, context.uid, identity, entry, options);
     return;
   }
-  const deliveryRegistered = await registerEpochDelivery(cloud, identity, context.epochState, entry.current, entry.deliveryRegistered === true, options);
   context.nextEntry = {
     ...entry,
     current: {
@@ -23089,7 +24000,9 @@ async function prepareReceivedEpochOwner(context) {
       settings: context.epochState.settings
     },
     routes: routesForManifest(entry, context.epochState),
-    deliveryRegistered,
+    deliveryRegistered: true,
+    attentionRegistrationVersion: CHAT_ATTENTION_REGISTRATION_VERSION,
+    notificationMode: normalizeChatNotificationMode(entry.notificationMode, context.epochState.manifest),
     notificationTag: notificationChatTag(context.epochState.stateCapability, parent.chatId, identity.chatPK)
   };
   context.historyId = ownEpochEntryId(identity.chatPrivateKey, parent.chatId, parent.epochId);
@@ -23118,8 +24031,11 @@ async function commitReceivedEpochOwner(context) {
         current: nextEntry.current,
         routes: routesForManifest(current, epochState),
         deliveryRegistered: current.deliveryRegistered || nextEntry.deliveryRegistered,
+        attentionRegistrationVersion: CHAT_ATTENTION_REGISTRATION_VERSION,
+        notificationMode: normalizeChatNotificationMode(current.notificationMode, epochState.manifest),
         notificationTag: nextEntry.notificationTag
       },
+      deliveryRegistration: epochDeliveryRegistration(identity, epochState, current.notificationMode),
       touchTs: true,
       epochs: [{
         id: historyId,
@@ -23133,8 +24049,17 @@ async function commitReceivedEpochOwner(context) {
     };
   });
 }
-function publishReceivedEpochTransition(context) {
+async function publishReceivedEpochTransition(context) {
   assertInboxLease(context.options);
+  if (context.entry.deliveryRegistered) {
+    const oldCapability = deriveChatDeliveryCapability(context.entry.current.stateCapability, {
+      chatId: context.parent.chatId,
+      recipientChatPK: context.identity.chatPK,
+      generation: context.parent.epochVersion
+    });
+    await context.cloud.delivery.revoke(oldCapability).catch(() => false);
+    assertInboxLease(context.options);
+  }
   context.options.onTransition?.(projectOwnChatEntry(context.committedEntry, context.entryId, context.identity.chatPK, context.nowMs), {
     ...context.action,
     membershipCommitted: true
@@ -23397,12 +24322,17 @@ async function prepareInboxWork(context, prepared, processingOptions = {}) {
       currentChats: state.currentChats,
       discoveryStartedAt: prepared.startedAt,
       mlsKeyPackageStateCache: context.mlsKeyPackageStateCache,
+      consumedMlsKeyPackageIds: context.consumedMlsKeyPackageIds,
       mlsPackageCache: context.mlsPackageCache,
       settingsRecordCache: context.settingsRecordCache,
       onInboxCommit: state.commitOwner,
       onTransition: state.publishTransition,
-      onInboxDelete: state.publishDelete
+      onInboxDelete: state.publishDelete,
+      requestToken: `${document?.slot === true ? "slot" : "ping"}:${cleanText(document?.id)}`
     });
+    if (ping.opened?.result === "request") {
+      await hydrateOpenedChatRequest(ping.opened.context);
+    }
     announcement = announcePreparedWelcome(context, authenticated, ping, document, prepared.startedAt);
     return { announcement, document, ping, prepared, processingOptions, status: null };
   } catch (error) {
@@ -23427,6 +24357,11 @@ async function settleInboxWork(context, work, onAuthoritative) {
       result: result === true ? "applied" : cleanText(result) || "ignored",
       slot: document?.slot === true
     });
+    if (result === "request") {
+      options.onInboxRequest?.(work.announcement, document);
+      options.onPingSettled?.(document, result);
+      return "request";
+    }
     if (result !== "duplicate")
       state.processed += 1;
     if (!document.slot || result === "deleted") {
@@ -23730,6 +24665,7 @@ async function processInbox(cloud, uid, userChatPK, userPrivKey, options = {}) {
   const context = {
     blockedUids,
     cloud,
+    consumedMlsKeyPackageIds: new Set,
     discoveryPool: createInboxWorkPool(CHAT_INBOX_DISCOVERY_PARALLEL_CHATS),
     identity,
     mlsKeyPackageStateCache: new Map,
@@ -23900,6 +24836,8 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
   let inboxRequestedRetryDelayMs = null;
   const priorityInboxDocuments = new Map;
   const activeInboxDocuments = new Map;
+  const pendingChatRequests = new Map;
+  const chatRequestResolutions = new Map;
   const inboxPendingAttempts = new Map;
   const leaveProposalObservedAt = new Map;
   let closed = false;
@@ -23928,8 +24866,17 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
   const revokeInboxAnnouncement = (chatId, token) => {
     if (closed)
       return false;
+    if (pendingChatRequests.get(chatId)?.announcement?.token === token) {
+      pendingChatRequests.delete(chatId);
+    }
     return options.onInboxRevoke?.(chatId, token) ?? false;
   };
+  const retainInboxRequest = (announcement, document) => {
+    if (closed || !announcement?.messageRequest || !announcement?.chatId || !announcement?.token)
+      return false;
+    pendingChatRequests.set(announcement.chatId, { announcement, document });
+    return true;
+  };
   const publishInboxTransition = (chat, message) => {
     if (closed)
       return false;
@@ -24007,6 +24954,10 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
       notificationPrivateKey: options.notificationPrivateKey,
       mls: options.mls,
       blockedUids: options.blockedUids,
+      chatAdmission: options.chatAdmission,
+      incomingChatDecision: options.incomingChatDecision,
+      chatRequestResolutions,
+      onInboxRequest: retainInboxRequest,
       sinceMs: inboxSinceMs,
       priorityDocuments,
       settlementController,
@@ -24052,7 +25003,7 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
         retryRequested = true;
         return true;
       },
-      onPingSettled: (doc) => {
+      onPingSettled: (doc, result) => {
         const key = inboxRetryKey(doc);
         if (key)
           inboxPendingAttempts.delete(key);
@@ -24060,6 +25011,12 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
         if (priorityKey && chatDocDataEqual(priorityInboxDocuments.get(priorityKey), doc)) {
           priorityInboxDocuments.delete(priorityKey);
         }
+        const resolution = chatRequestResolutions.get(priorityKey);
+        if (resolution && result !== "request") {
+          chatRequestResolutions.delete(priorityKey);
+          pendingChatRequests.delete(resolution.chatId);
+          resolution.resolve(result === true || result === "rejected");
+        }
       },
       onPingStarted: (doc) => {
         const key = inboxDocumentKey2(doc);
@@ -24135,6 +25092,27 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
       setTimeout(processQueuedInbox, 0);
     }
   };
+  const resolveChatRequest = (chatId, decision) => {
+    const request = pendingChatRequests.get(chatId);
+    if (!request?.document || !["accept", "reject"].includes(decision))
+      return Promise.resolve(false);
+    const token = request.announcement.token;
+    const existing = chatRequestResolutions.get(token);
+    if (existing)
+      return existing.promise;
+    let resolve;
+    let reject;
+    const promise = new Promise((resolveValue, rejectValue) => {
+      resolve = resolveValue;
+      reject = rejectValue;
+    });
+    chatRequestResolutions.set(token, { chatId, decision, promise, reject, resolve });
+    priorityInboxDocuments.set(token, request.document);
+    inboxQueued = true;
+    if (!inboxProcessing)
+      setTimeout(processQueuedInbox, 0);
+    return promise;
+  };
   const schedule = (delayMs) => {
     if (timer || processing || closed) {
       return;
@@ -24194,13 +25172,19 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
     inboxQueued = false;
     priorityInboxDocuments.clear();
     activeInboxDocuments.clear();
+    for (const resolution of chatRequestResolutions.values()) {
+      resolution.reject(new Error("chat inbox closed"));
+    }
+    chatRequestResolutions.clear();
+    pendingChatRequests.clear();
     unsub?.();
     tokenUnsub?.();
     inboxUnsub?.();
   };
   return Object.freeze({
     close,
-    prioritizeChat: (chatId) => settlementController.prioritizeChat(chatId)
+    prioritizeChat: (chatId) => settlementController.prioritizeChat(chatId),
+    resolveChatRequest
   });
 }
 async function loadMoreChats(cloud, uid, userChatPK, userPrivKey, afterChat, pageSize) {
@@ -24282,7 +25266,7 @@ async function getChat(cloud, uid, chatId, userChatPK, userPrivKey) {
 }
 async function decryptChatEntry(entryRecord, userChatPK, userPrivKey) {
   const data = entryRecord;
-  const entry = await openOwnChatEntry(userPrivKey, entryRecord.id, data?.body);
+  const entry = await openOwnChatRecord(userPrivKey, entryRecord.id, data);
   if (entry.ownerRevision !== data?.revision) {
     throw new Error("chat owner revision mismatch");
   }
@@ -24320,6 +25304,8 @@ async function decryptChatEntry(entryRecord, userChatPK, userPrivKey) {
     readMs: null,
     startMs,
     deliveryRegistered: entry.deliveryRegistered === true,
+    attentionRegistrationVersion: entry.attentionRegistrationVersion,
+    notificationMode: entry.notificationMode,
     routes: entry.routes,
     peerDeliveryCapability: directPeer ? entry.routes?.[directPeer.chatPK]?.deliveryCapability || null : null,
     peerNotificationPK: directPeer?.notificationPK || null,
@@ -24597,12 +25583,14 @@ function announcementRow(announcement, selfChatPK) {
     peerChatPK: directPeer?.chatPK || null,
     peerUid: directPeer?.uid || null,
     settings: announcement.settings || {},
-    preview: null,
+    preview: announcement.preview || null,
     readMs: null,
     inboxMessageId: announcement.messageId || null,
     inboxMessageAt: at,
     ts: at,
-    unseen: false
+    unseen: announcement.messageRequest === true,
+    messageRequest: announcement.messageRequest === true,
+    requestToken: announcement.token
   };
 }
 function sourceEntry() {
@@ -24964,6 +25952,8 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
       settings: retiredEntry.current.settings.values,
       routes: retiredEntry.routes,
       deliveryRegistered: retiredEntry.deliveryRegistered === true,
+      attentionRegistrationVersion: retiredEntry.attentionRegistrationVersion,
+      notificationMode: retiredEntry.notificationMode,
       notificationTag: retiredEntry.notificationTag || null,
       epochState: retiredEntry.current,
       ownEntry: retiredEntry,
@@ -25050,6 +26040,8 @@ function createChatListIndex({ cache, filterHiddenChats, getSources, isHiddenCha
       peerSigningPublicKey: owner?.signingKeysByChatKey?.[peerChatPK] || "",
       signerShared: owner?.signerShared === true,
       deliveryRegistered: owner?.deliveryRegistered === true,
+      attentionRegistrationVersion: owner?.attentionRegistrationVersion || 0,
+      notificationMode: owner?.notificationMode || null,
       peerDeliveryCapability: owner?.peerDeliveryCapability || "",
       peerNotificationPK: owner?.peerNotificationPK || "",
       notificationTag: owner?.notificationTag || "",
@@ -25131,12 +26123,14 @@ function createChatListListener({
   let listening = false;
   let unsubscribeChats = null;
   let prioritizeInboxChat = null;
+  let resolveInboxChatRequest = null;
   let retryTimer = null;
   let updateSequence = 0;
   const stop = () => {
     unsubscribeChats?.();
     unsubscribeChats = null;
     prioritizeInboxChat = null;
+    resolveInboxChatRequest = null;
   };
   const retainAfterError = (error) => {
     const sources = getSources();
@@ -25295,6 +26289,8 @@ function createChatListListener({
       inboxTransport: sources.inboxTransport,
       mls: sources.mls,
       blockedUids: sources.blockedUidSet,
+      chatAdmission: sources.chatAdmission,
+      incomingChatDecision: sources.incomingChatDecision,
       localCache: sources.localCache,
       diag: sources.diag,
       getCurrentChat: index.getOwnerChat,
@@ -25305,6 +26301,7 @@ function createChatListListener({
       throw new Error("chat list subscription lifecycle required");
     }
     prioritizeInboxChat = subscription.prioritizeChat;
+    resolveInboxChatRequest = subscription.resolveChatRequest;
     unsubscribeChats = () => {
       cancelled = true;
       markDiag(getSources().diag, "chat.provider.listen.stop", { elapsedMs: Date.now() - listenStartedAt });
@@ -25322,6 +26319,7 @@ function createChatListListener({
     },
     isListening: () => listening,
     prioritizeChat: (chatId) => prioritizeInboxChat?.(chatId) || Promise.resolve(false),
+    resolveChatRequest: (chatId, decision) => resolveInboxChatRequest?.(chatId, decision) || Promise.resolve(false),
     start: () => {
       if (listening)
         return;
@@ -25922,6 +26920,7 @@ function createChatList(initialSources) {
     getRow: index.getRow,
     markChatRead: index.markChatRead,
     reconcileChatEpoch: epoch.reconcileChatEpoch,
+    resolveChatRequest: listener.resolveChatRequest,
     sendOptionsForPeer: index.sendOptionsForPeer,
     hasChat: paging.hasChat
   };
@@ -26490,20 +27489,24 @@ function memberFromChatIdentity(value) {
     uid: identity.uid,
     chatPK: identity.chatPK,
     chatSigningPK: identity.chatSigningPK,
-    notificationPK: identity.notificationPK
+    notificationPK: identity.notificationPK,
+    ...value?.admissionCapability ? { admissionCapability: cleanText(value.admissionCapability).toLowerCase() } : {}
   };
   const mlsLeafId = cleanText(value?.mlsLeafId).toLowerCase();
   return /^[0-9a-f]{64}$/u.test(mlsLeafId) ? { ...member, mlsLeafId } : member;
 }
 async function registerInitialDelivery(cloud, identity, epochState) {
-  const capability = deriveChatDeliveryCapability(epochState.stateCapability, {
+  const registration = chatDeliveryRegistration(epochState.stateCapability, {
+    attentionSecret: epochState.epochSecret,
     chatId: epochState.manifest.chatId,
     recipientChatPK: identity.chatPK,
-    generation: epochState.manifest.epochVersion
+    generation: epochState.manifest.epochVersion,
+    manifest: epochState.manifest
   });
-  return cloud.delivery.register(capability).then(() => true, () => false);
+  return cloud.delivery.register(registration).then(() => true, () => false);
 }
-function initialRoutes(manifest, stateCapability, ownerChatPK) {
+function initialRoutes(manifest, stateCapability, ownerChatPK, memberValues = []) {
+  const privateByChatPK = new Map(memberValues.map((member) => [member.chatPK, member]));
   return Object.fromEntries(manifest.members.map((member) => [member.chatPK, {
     uid: member.uid,
     deliveryCapability: manifest.lineage === CHAT_LINEAGES.GROUP || member.chatPK === ownerChatPK ? deriveChatDeliveryCapability(stateCapability, {
@@ -26512,13 +27515,14 @@ function initialRoutes(manifest, stateCapability, ownerChatPK) {
       generation: manifest.epochVersion
     }) : null,
     notificationPK: member.notificationPK,
+    admissionCapability: privateByChatPK.get(member.chatPK)?.admissionCapability || null,
     generation: manifest.epochVersion
   }]));
 }
 async function prepareInitialOwner(identity, epochState, fields = {}) {
   const entryId = ownChatEntryId(identity.chatPrivateKey, epochState.manifest.chatId);
   const entry = makeOwnChatEntry(epochState, {
-    routes: initialRoutes(epochState.manifest, epochState.stateCapability, identity.chatPK),
+    routes: initialRoutes(epochState.manifest, epochState.stateCapability, identity.chatPK, fields.members),
     startMs: Date.now(),
     deliveryRegistered: fields.deliveryRegistered === true,
     notificationTag: notificationChatTag(epochState.stateCapability, epochState.manifest.chatId, identity.chatPK)
@@ -26533,6 +27537,7 @@ async function prepareInitialOwner(identity, epochState, fields = {}) {
       entryId,
       record: {
         body: await sealOwnChatEntry(identity.chatPrivateKey, entryId, entry),
+        notificationBody: await sealOwnChatNotificationPreference(identity.chatPrivateKey, entryId, entry),
         revision: entry.ownerRevision,
         tsMs
       }
@@ -26632,7 +27637,8 @@ async function createGroupChat(cloud, identityValue, memberValues, settings = {}
     const stateId = chatMlsStateId(identity.chatPrivateKey, chatId, initial.transitionCommitment);
     const ownerMlsState = await sealChatMlsState(identity.chatPrivateKey, stateId, { v: 1, chatId, transitionCommitment: initial.transitionCommitment }, mlsGroup.snapshot);
     const owner = await prepareInitialOwner(identity, initialState, {
-      deliveryRegistered: true
+      deliveryRegistered: true,
+      members
     });
     let stateError = null;
     try {
@@ -26746,7 +27752,7 @@ async function createGroupChat(cloud, identityValue, memberValues, settings = {}
 
 // ../../core/chat/direct.js
 "use client";
-function orderedChatKeys(first, second) {
+function orderedChatKeys2(first, second) {
   return [
     cleanChatHex(first, "chat public key"),
     cleanChatHex(second, "peer chat public key")
@@ -26768,7 +27774,7 @@ function deriveDirectRouteId(chatPrivateKey, chatPK, peerChatPK) {
   try {
     peerKey = fromHex(otherChatPK, "peer chat public key");
     shared = x25519.getSharedSecret(toBytes32(chatPrivateKey, "chat private key"), peerKey);
-    routeId = deriveKey(shared, "direct-route-id-v3", orderedChatKeys(ownChatPK, otherChatPK));
+    routeId = deriveKey(shared, "direct-route-id-v3", orderedChatKeys2(ownChatPK, otherChatPK));
     return toHex(routeId);
   } finally {
     cleanBytes(peerKey, shared, routeId);
@@ -26918,6 +27924,9 @@ function createChatSessionLaunches({
       setSelectedChat(existingChatId);
       return existingChatId;
     }
+    if (directAdmissionForPeer(operation.identity.chatPrivateKey, chatPK, profile) === CHAT_ADMISSION_DECISIONS.REJECT) {
+      throw new Error("peer is not accepting direct chats");
+    }
     const routeId = directRouteIdForPeer(member.chatPK, operation);
     if (operation.pendingOwner.getPendingLaunch()?.id === routeId)
       return routeId;
@@ -26986,6 +27995,13 @@ function createChatSessionLaunches({
     const profileList = Array.isArray(profiles) ? profiles : [profiles];
     const blockedSet = new Set(blocked);
     const requestedMembers = profileList.map(profileMember);
+    if (profileList.length === 1) {
+      if (directAdmissionForPeer(chatPrivateKey, chatPK, profileList[0]) === CHAT_ADMISSION_DECISIONS.REJECT) {
+        throw new Error("peer is not accepting direct chats");
+      }
+    } else if (profileList.length > 1 && profileList.some((profile) => !canInviteToGroup(profile))) {
+      throw new Error("peer is not accepting group invitations");
+    }
     for (const member of requestedMembers) {
       if (member.chatPK === chatPK)
         throw new Error("current user is already a chat member");
@@ -27114,6 +28130,9 @@ function createChatSessionLaunches({
       directOpens.delete(routeId);
       return runExistingDirectLifecycle(existingChatId, lifecycle, operation);
     }
+    if (directAdmissionForPeer(operation.identity.chatPrivateKey, chatPK, profile) === CHAT_ADMISSION_DECISIONS.REJECT) {
+      throw new Error("peer is not accepting direct chats");
+    }
     const resolution = startDirectResolution(routeId, member.chatPK, operation);
     const state = { operation, promise: null };
     state.promise = resolution.promise.then((resolvedChatId) => {
@@ -27195,6 +28214,7 @@ function createChatSessionPending({
   setSelectedChat,
   publish,
   getOwnerChat,
+  getChatRow,
   ensureChat,
   profileMember,
   transitionIdentity,
@@ -27559,7 +28579,7 @@ function createChatSessionPending({
         setSelectedChat(chatId);
         return true;
       };
-      if (pendingMatches || getOwnerChat(chatId))
+      if (pendingMatches || getOwnerChat(chatId) || getChatRow(chatId)?.messageRequest)
         return selectResolved();
       return Promise.resolve(ensureChat(chatId)).then((ready) => ready === true && selectResolved());
     },
@@ -27632,11 +28652,13 @@ function createChatSessionMembership({
     if (!profile?.uid || !profile?.chatPK || !profile?.chatSigningPK || !profile?.notificationPK) {
       throw new Error("complete peer chat identity required");
     }
+    const identity = getIdentity();
     return {
       uid: profile.uid,
       chatPK: profile.chatPK,
       chatSigningPK: profile.chatSigningPK,
-      notificationPK: profile.notificationPK
+      notificationPK: profile.notificationPK,
+      admissionCapability: deriveDirectAdmissionCapability(identity.chatPrivateKey, identity.chatPK, profile.chatPK, profile.chatPK)
     };
   };
   const prepareMlsAdditions = async (profiles, operation = operationContext()) => {
@@ -27880,7 +28902,12 @@ function createChatSessionMembership({
     return state.promise;
   };
   const addChatMembers = (chatId, profiles) => {
-    const additions = (Array.isArray(profiles) ? profiles : [profiles]).map(profileMember);
+    const profileList = Array.isArray(profiles) ? profiles : [profiles];
+    for (const profile of profileList) {
+      if (!canInviteToGroup(profile))
+        throw new Error("peer is not accepting group invitations");
+    }
+    const additions = profileList.map(profileMember);
     const blockedSet = new Set(getIdentity().blocked);
     for (const member of additions) {
       if (blockedSet.has(member.uid))
@@ -27938,7 +28965,7 @@ function createChatSessionMembership({
 
 // ../../core/chat/deletiondelivery.js
 "use client";
-async function deliverChatDeletedPings(cloud, identityValue, epochState, members = [], eventIdValue = "") {
+async function deliverChatDeletedPings(cloud, identityValue, epochState, members = [], eventIdValue = "", routes = {}) {
   const identity = {
     ...identityValue,
     uid: cleanText(identityValue?.uid),
@@ -27976,6 +29003,7 @@ async function deliverChatDeletedPings(cloud, identityValue, epochState, members
     deliveries.push({
       member,
       promise: pushCriticalInbox(cloud, member.uid, ping, {
+        admissionCapability: routes?.[member.chatPK]?.admissionCapability || null,
         descriptor,
         routeTag: notificationRouteTag(descriptor),
         notify: true
@@ -28179,6 +29207,7 @@ function createChatDelete({
         stateCapability: serverChat?.epochState?.stateCapability,
         epochVersion: serverChat?.epochVersion,
         members: serverChat?.members || [],
+        routes: sourceChat?.routes || {},
         transitionCommitment: serverChat?.epochState?.transitionCommitment,
         ownEntry: sourceChat?.ownEntry || null,
         membershipRemoved: sourceChat?.membershipRemoved === true,
@@ -28225,7 +29254,7 @@ function createChatDelete({
       },
       stateCapability: target.stateCapability,
       transitionCommitment: target.transitionCommitment
-    }, target.members, target.expectedEpochId);
+    }, target.members, target.expectedEpochId, target.routes);
     return result.deliveredCount;
   };
   const deleteCurrentChat = async (input, options = {}) => {
@@ -29356,6 +30385,188 @@ function createChatSessionSettings({
   };
 }
 
+// ../../core/chat/sessionnotifications.js
+var CHAT_ATTENTION_REFRESH_CONCURRENCY = 4;
+function currentNotificationRegistration(identity, entry, notificationMode = entry?.notificationMode) {
+  const manifest = entry?.current?.manifest;
+  if (!manifest || !identity?.chatPK)
+    throw makeChatUnavailableError();
+  const mode = normalizeChatNotificationMode(notificationMode, manifest);
+  return {
+    deliveryRegistration: chatDeliveryRegistration(entry.current.stateCapability, {
+      attentionSecret: entry.current.epochSecret,
+      chatId: manifest.chatId,
+      recipientChatPK: identity.chatPK,
+      generation: manifest.epochVersion,
+      manifest,
+      notificationMode: mode
+    }),
+    notificationMode: mode
+  };
+}
+function entryWithCurrentNotificationRegistration(entry, notificationMode) {
+  return {
+    ...entry,
+    deliveryRegistered: true,
+    attentionRegistrationVersion: CHAT_ATTENTION_REGISTRATION_VERSION,
+    notificationMode
+  };
+}
+async function setOwnChatNotificationMode(cloud, identity, entryId, entry, value) {
+  if (!entryId || !entry?.current || entry.retirement)
+    throw makeChatUnavailableError();
+  return mutateOwnChatEntry(cloud, identity, entryId, entry, (current) => {
+    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) {
+      throw new Error("all notifications are unavailable in large groups");
+    }
+    if (current.notificationMode === notificationMode && hasCurrentChatAttentionRegistration(current)) {
+      return { result: current };
+    }
+    const { deliveryRegistration } = currentNotificationRegistration(identity, current, notificationMode);
+    return {
+      entry: entryWithCurrentNotificationRegistration(current, notificationMode),
+      deliveryRegistration
+    };
+  });
+}
+async function refreshOwnChatAttentionRegistration(cloud, identity, entryId, entry) {
+  if (!entryId || !entry?.current || entry.retirement)
+    throw makeChatUnavailableError();
+  return mutateOwnChatEntry(cloud, identity, entryId, entry, (current) => {
+    if (!current?.current || current.retirement)
+      throw makeChatUnavailableError();
+    if (hasCurrentChatAttentionRegistration(current))
+      return { result: current };
+    const { deliveryRegistration, notificationMode } = currentNotificationRegistration(identity, current);
+    return {
+      entry: entryWithCurrentNotificationRegistration(current, notificationMode),
+      deliveryRegistration
+    };
+  });
+}
+function createChatSessionNotifications({
+  cloud,
+  getGeneration,
+  getIdentity,
+  getOwnerChat,
+  getMutationGate,
+  getChatListOwner,
+  loadOwnerChats = async () => [],
+  writeMode = setOwnChatNotificationMode,
+  writeRegistration = refreshOwnChatAttentionRegistration
+}) {
+  let refreshState = null;
+  let refreshedGeneration = null;
+  let refreshedListOwner = null;
+  const operationContext = () => ({
+    generation: getGeneration(),
+    identity: getIdentity(),
+    listOwner: getChatListOwner(),
+    mutationGate: getMutationGate()
+  });
+  const assertCurrent = (operation) => {
+    if (getGeneration() !== operation.generation || getChatListOwner() !== operation.listOwner) {
+      throw makeChatUnavailableError();
+    }
+  };
+  const requireOwnerChat = (chatId, operation, { group = false } = {}) => {
+    assertCurrent(operation);
+    const chat = getOwnerChat(chatId);
+    if (operation.identity.chatBanned || group && chat?.lineage !== "group" || !chat.ownEntry || chat.ownEntry.retirement || !chat.entryId) {
+      throw makeChatUnavailableError();
+    }
+    return chat;
+  };
+  const setChatNotificationMode = async (chatId, mode) => {
+    const operation = operationContext();
+    requireOwnerChat(chatId, operation, { group: true });
+    const releaseMutation = await operation.mutationGate.acquireExclusive(chatId);
+    try {
+      const chat = requireOwnerChat(chatId, operation, { group: true });
+      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);
+      operation.listOwner.commitOwner(projected);
+      return projected.notificationMode;
+    } finally {
+      releaseMutation();
+    }
+  };
+  const refreshLoadedChat = async (chat, operation) => {
+    assertCurrent(operation);
+    if (!chat?.id || !chat.entryId || !chat.ownEntry?.current || chat.ownEntry.retirement || hasCurrentChatAttentionRegistration(chat.ownEntry)) {
+      return false;
+    }
+    const releaseMutation = await operation.mutationGate.acquireExclusive(chat.id);
+    try {
+      assertCurrent(operation);
+      const committed = await writeRegistration(cloud, operation.identity, chat.entryId, chat.ownEntry);
+      assertCurrent(operation);
+      const projected = projectOwnChatEntry(committed, chat.entryId, operation.identity.chatPK, chat.ts);
+      operation.listOwner.commitOwner(projected);
+      return true;
+    } finally {
+      releaseMutation();
+    }
+  };
+  const startAttentionRegistrationRefresh = (operation) => {
+    const state = { operation, promise: null };
+    state.promise = (async () => {
+      const { chatBanned, chatPK, chatPrivateKey, uid } = operation.identity;
+      if (chatBanned || !uid || !chatPK || !chatPrivateKey)
+        throw makeChatUnavailableError();
+      const chats = await loadOwnerChats(cloud, uid, chatPK, chatPrivateKey);
+      assertCurrent(operation);
+      const pending = (chats || []).filter((chat) => chat?.id && chat.entryId && chat.ownEntry?.current && !chat.ownEntry.retirement && !hasCurrentChatAttentionRegistration(chat.ownEntry));
+      let cursor = 0;
+      let refreshed = 0;
+      const failures = [];
+      const worker = async () => {
+        while (cursor < pending.length) {
+          const chat = pending[cursor];
+          cursor += 1;
+          try {
+            if (await refreshLoadedChat(chat, operation))
+              refreshed += 1;
+          } catch (error) {
+            failures.push(error);
+          }
+        }
+      };
+      await Promise.all(Array.from({ length: Math.min(CHAT_ATTENTION_REFRESH_CONCURRENCY, pending.length) }, worker));
+      assertCurrent(operation);
+      if (failures.length)
+        throw failures[0];
+      refreshedGeneration = operation.generation;
+      refreshedListOwner = operation.listOwner;
+      return refreshed;
+    })().finally(() => {
+      if (refreshState === state)
+        refreshState = null;
+    });
+    refreshState = state;
+    return state.promise;
+  };
+  const refreshChatAttentionRegistrations = () => {
+    const operation = operationContext();
+    if (refreshedGeneration === operation.generation && refreshedListOwner === operation.listOwner) {
+      return Promise.resolve(0);
+    }
+    if (refreshState && refreshState.operation.generation === operation.generation && refreshState.operation.listOwner === operation.listOwner) {
+      return refreshState.promise;
+    }
+    return startAttentionRegistrationRefresh(operation);
+  };
+  return { refreshChatAttentionRegistrations, setChatNotificationMode };
+}
+
 // ../../core/chat/sessionsources.js
 function normalizeChatSessionSources(sources = {}) {
   return {
@@ -29369,11 +30580,12 @@ function normalizeChatSessionSources(sources = {}) {
     chatSigningSecret: sources.chatSigningSecret || null,
     notificationPK: sources.notificationPK || "",
     notificationPrivateKey: sources.notificationPrivateKey || "",
+    chatAdmission: sources.chatAdmission || null,
     localCache: sources.localCache || null
   };
 }
 function chatSessionAuthChanged(previous, next) {
-  return previous.uid !== next.uid || previous.chatPK !== next.chatPK || previous.chatBanned !== next.chatBanned || previous.chatPrivateKey !== next.chatPrivateKey || previous.chatSigningPK !== next.chatSigningPK || previous.chatSigningSecret !== next.chatSigningSecret || previous.notificationPK !== next.notificationPK || previous.notificationPrivateKey !== next.notificationPrivateKey || previous.localCache !== next.localCache;
+  return previous.uid !== next.uid || previous.chatPK !== next.chatPK || previous.chatBanned !== next.chatBanned || previous.chatPrivateKey !== next.chatPrivateKey || previous.chatSigningPK !== next.chatSigningPK || previous.chatSigningSecret !== next.chatSigningSecret || previous.notificationPK !== next.notificationPK || previous.notificationPrivateKey !== next.notificationPrivateKey || previous.chatAdmission !== next.chatAdmission || previous.localCache !== next.localCache;
 }
 
 // ../../core/chat/session.js
@@ -29403,15 +30615,21 @@ function createChatSession({
   chatWarming = false,
   preloadMessageMedia,
   adoptLocalMessageMedia,
+  refreshAttentionRegistrationsOnStart = false,
   chatCrypto = null,
   mls = null,
   live = null,
+  maintenance,
+  incomingChatDecision = null,
   diag = null,
   loadOwnerChats = loadAllChats
 }, initialSources = {}) {
   if (!cloud) {
     throw new Error("createChatSession requires cloud");
   }
+  if (!maintenance?.claim || !maintenance?.open || !maintenance?.close) {
+    throw new Error("createChatSession requires account message maintenance");
+  }
   let {
     uid = "",
     blocked = [],
@@ -29423,6 +30641,7 @@ function createChatSession({
     chatPrivateKey = "",
     notificationPK = "",
     notificationPrivateKey = "",
+    chatAdmission = null,
     localCache = null
   } = initialSources;
   let isActive = isForegroundAppState(appState?.currentState);
@@ -29435,6 +30654,9 @@ function createChatSession({
   let mlsPoolLastCheckedAt = 0;
   let mlsPoolGeneration = 0;
   let authGeneration = 0;
+  let attentionRegistrationPreparation = null;
+  let attentionRegistrationReadyGeneration = null;
+  let attentionRegistrationReadyOwner = null;
   const inboxSource = () => ({
     uid,
     chatPK,
@@ -29466,6 +30688,7 @@ function createChatSession({
   let pendingOwner = null;
   let membershipOwner = null;
   let settingsOwner = null;
+  let notificationsOwner = null;
   let chatListOwner = null;
   let unsubscribeChatList = null;
   let selectionIntent = 0;
@@ -29648,11 +30871,48 @@ function createChatSession({
     diag
   });
   const drainMembershipOutbox = () => {
-    if (!uid || !chatPK || !chatPrivateKey || !chatSigningPK || !chatSigningSecret)
-      return;
-    drainChatMembershipOutbox(cloud, transitionIdentity()).catch((error) => {
+    if (!uid || !chatPK || !chatPrivateKey || !chatSigningPK || !chatSigningSecret) {
+      return Promise.resolve(0);
+    }
+    return drainChatMembershipOutbox(cloud, transitionIdentity()).catch((error) => {
       markDiag(diag, "chat.membership.outbox.failed", { message: error?.message || String(error) });
+      return 0;
+    });
+  };
+  const refreshAttentionRegistrations = () => {
+    if (!refreshAttentionRegistrationsOnStart || !isActive || chatBanned || !notificationsOwner)
+      return null;
+    const generation = authGeneration;
+    const owner = notificationsOwner;
+    if (attentionRegistrationReadyGeneration === generation && attentionRegistrationReadyOwner === owner) {
+      return Promise.resolve(0);
+    }
+    if (attentionRegistrationPreparation?.generation === generation && attentionRegistrationPreparation.owner === owner) {
+      return attentionRegistrationPreparation.promise;
+    }
+    const state = { generation, owner, promise: null };
+    state.promise = owner.refreshChatAttentionRegistrations().then((refreshed) => {
+      if (authGeneration !== generation || notificationsOwner !== owner || !isActive)
+        return 0;
+      attentionRegistrationReadyGeneration = generation;
+      attentionRegistrationReadyOwner = owner;
+      if (refreshed > 0) {
+        markDiag(diag, "chat.notifications.routes.refreshed", { count: refreshed });
+      }
+      return refreshed;
+    }).catch((error) => {
+      if (authGeneration === generation && notificationsOwner === owner) {
+        markDiag(diag, "chat.notifications.routes.failed", {
+          message: error?.message || String(error)
+        });
+      }
+      return 0;
+    }).finally(() => {
+      if (attentionRegistrationPreparation === state)
+        attentionRegistrationPreparation = null;
     });
+    attentionRegistrationPreparation = state;
+    return state.promise;
   };
   const replenishMlsPool = ({ force = false } = {}) => {
     if (!uid || !chatPK || !chatPrivateKey || !chatSigningPK || !chatSigningSecret)
@@ -29731,6 +30991,20 @@ function createChatSession({
     getChatListOwner: () => chatListOwner,
     setLocalByChat
   });
+  notificationsOwner = createChatSessionNotifications({
+    cloud,
+    getGeneration: () => authGeneration,
+    getIdentity: () => ({
+      uid,
+      chatPK,
+      chatPrivateKey,
+      chatBanned
+    }),
+    getOwnerChat,
+    getMutationGate: () => actionOwner.mutationGate,
+    getChatListOwner: () => chatListOwner,
+    loadOwnerChats
+  });
   pendingOwner = createChatSessionPending({
     beginSelection: beginChatSelection,
     getIdentity: () => ({ uid, blocked, chatPK, chatPrivateKey, chatBanned }),
@@ -29738,6 +31012,7 @@ function createChatSession({
     setSelectedChat,
     publish,
     getOwnerChat,
+    getChatRow: (chatId) => chatListOwner.getRow(chatId),
     ensureChat,
     profileMember: membershipOwner.profileMember,
     transitionIdentity,
@@ -29769,12 +31044,16 @@ function createChatSession({
   const selectChat = (chatId) => pendingOwner.selectChat(chatId, {
     flushPrevious: (previousChatId) => actionOwner.seenActions.flushChatRead(previousChatId)
   });
+  const resolveChatRequest = (chatId, decision) => chatListOwner.resolveChatRequest(chatId, decision);
   const getPeerChatId = (...args) => launchOwner.getPeerChatId(...args);
   const resolvePeerChatId = (...args) => launchOwner.resolvePeerChatId(...args);
   const selectPeerChat = (...args) => launchOwner.selectPeerChat(...args);
   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);
+  const canStartDirectChat2 = (profile) => canStartDirectChat(chatPrivateKey, chatPK, profile);
+  const canInviteToGroup2 = (profile) => canInviteToGroup(profile);
   const createGroupChat2 = (...args) => launchOwner.createGroupChat(...args);
   const selectLocalChat = (...args) => launchOwner.selectLocalChat(...args);
   const addChatMembers = (chatId, profiles) => {
@@ -29792,6 +31071,7 @@ function createChatSession({
   const leaveOwnedChat = (...args) => membershipOwner.leaveOwnedChat(...args);
   const updateChatSettings2 = gateChatMutation((...args) => settingsOwner.updateChatSettings(...args));
   const updateChatAvatar = gateChatMutation((...args) => settingsOwner.updateChatAvatar(...args));
+  const setChatNotificationMode = gateChatMutation((...args) => notificationsOwner.setChatNotificationMode(...args));
   const updateMessage = (chatId, msgId, newMessage, peerChatPK) => {
     if (chatBanned)
       throw makeChatUnavailableError();
@@ -29914,6 +31194,8 @@ function createChatSession({
         notificationPrivateKey: identity.notificationPrivateKey,
         mls,
         blockedUids: new Set(identity.blocked),
+        chatAdmission,
+        incomingChatDecision,
         scanAllSlots: true,
         requireComplete: true
       });
@@ -30117,7 +31399,8 @@ function createChatSession({
     getChatPreviewKey: getChatPreviewKey2,
     writeChatPreview,
     chatCrypto,
-    diag
+    diag,
+    maintenance
   };
   const batchSources = () => ({
     cloud,
@@ -30131,6 +31414,7 @@ function createChatSession({
     chatBanned,
     isActive,
     localCache,
+    maintenance,
     listRef: lastServerChatsRef,
     pendingDeleteIdsRef: actionOwner.deleteActions.pendingDeleteIdsRef,
     config: chatWarming,
@@ -30157,6 +31441,8 @@ function createChatSession({
     localCache,
     isActive,
     inboxTransport,
+    chatAdmission,
+    incomingChatDecision,
     diag,
     selectedChatId: stateOwner.getSelectedChatId(),
     selectedChatIdRef,
@@ -30212,18 +31498,23 @@ function createChatSession({
   stateOwner.setActions({
     loadMoreChats: loadMoreChats2,
     selectChat,
+    resolveChatRequest,
     getPeerChatId,
     resolvePeerChatId,
     selectPeerChat,
     openDirectChat,
     openNotesChat,
     openNewChat,
+    directAdmissionForPeer: directAdmissionForPeer2,
+    canStartDirectChat: canStartDirectChat2,
+    canInviteToGroup: canInviteToGroup2,
     createGroupChat: createGroupChat2,
     addChatMembers,
     kickChatMember,
     leaveChat,
     updateChatSettings: updateChatSettings2,
     updateChatAvatar,
+    setChatNotificationMode,
     dropChat,
     dropUnavailableChat,
     deleteChat,
@@ -30345,6 +31636,7 @@ function createChatSession({
     if (value) {
       if (selectedChatIdRef.current)
         enterChatActivity(selectedChatIdRef.current);
+      refreshAttentionRegistrations();
       drainMembershipOutbox();
       replenishMlsPool();
     }
@@ -30358,7 +31650,7 @@ function createChatSession({
   };
   const setSources = (nextSources = {}) => {
     const previousBlockedKey = [...blocked].sort().join("|");
-    const current = { uid, chatPK, chatBanned, chatPrivateKey, chatSigningPK, chatSigningSecret, notificationPK, notificationPrivateKey, localCache };
+    const current = { uid, chatPK, chatBanned, chatPrivateKey, chatSigningPK, chatSigningSecret, notificationPK, notificationPrivateKey, chatAdmission, localCache };
     const next = normalizeChatSessionSources(nextSources);
     const authChanged = chatSessionAuthChanged(current, next);
     if (authChanged) {
@@ -30376,6 +31668,7 @@ function createChatSession({
       chatSigningSecret,
       notificationPK,
       notificationPrivateKey,
+      chatAdmission,
       localCache
     } = next);
     inboxTransport.setSource(inboxSource());
@@ -30393,6 +31686,7 @@ function createChatSession({
     }
     publish();
     if (authChanged && isActive) {
+      refreshAttentionRegistrations();
       drainMembershipOutbox();
       replenishMlsPool({ force: true });
     }
@@ -30406,10 +31700,13 @@ function createChatSession({
   const start = () => {
     if (started)
       return;
+    maintenance.open();
     started = true;
     unsubscribeChatList = chatListOwner.subscribe(() => {
       stateOwner.setListSnapshot(chatListOwner.getSnapshot());
       publish();
+      if (serverChatsReadyRef.current)
+        refreshAttentionRegistrations();
     });
     stateOwner.setListSnapshot(chatListOwner.getSnapshot());
     publish();
@@ -30420,6 +31717,7 @@ function createChatSession({
         markDiag(diag, "chat.block.retire.failed", { message: error?.message || String(error) });
       });
     }
+    refreshAttentionRegistrations();
     drainMembershipOutbox();
     replenishMlsPool({ force: true });
     if (appState?.addEventListener) {
@@ -30428,6 +31726,7 @@ function createChatSession({
   };
   const close = () => {
     authGeneration += 1;
+    maintenance.close();
     settingsOwner.reset();
     mls?.close?.();
     if (!started)
@@ -33180,18 +34479,261 @@ function isPasswordStrengthAcceptable(feedback) {
   return feedback?.version === PASSWORD_STRENGTH_VERSION && feedback.acceptable === true;
 }
 
-// ../../core/username.js
-var MAX_USERNAME = USERNAME_MAX_CHARS;
-var usernameStripRegex = /[^a-z0-9]/g;
-var usernameRegex = new RegExp(`^[a-z0-9]{1,${MAX_USERNAME}}$`);
-function normalizeUsername(value = "") {
-  return String(value).trim().toLowerCase();
+// ../../core/wallet/invoice.js
+var import_bech322 = __toESM(require_dist(), 1);
+var externalInvoiceType = Object.freeze({
+  lightning: "lightning",
+  spark: "spark"
+});
+function lightningValue(value) {
+  const raw = cleanText(typeof value === "string" ? value : value?.invoice ?? value?.encodedInvoice ?? value?.bolt11);
+  const lower = lowerText(raw);
+  if (!lower)
+    return null;
+  const invoice = lower.startsWith("lightning://") ? raw.slice(12).trim() : lower.startsWith("lightning:") ? raw.slice(10).trim() : raw;
+  return /^ln[a-z0-9]+$/.test(lowerText(invoice)) ? invoice : null;
 }
-function cleanUsername(value = "") {
-  return normalizeUsername(value).replace(usernameStripRegex, "").slice(0, MAX_USERNAME);
+function ceilDiv(value, divisor) {
+  return (value + divisor - 1n) / divisor;
 }
-function isUsername(value = "") {
-  return usernameRegex.test(value);
+function wordsValue(words) {
+  let value = 0;
+  for (const word of words) {
+    value = value * 32 + word;
+    if (!Number.isSafeInteger(value))
+      return null;
+  }
+  return value;
+}
+function lightningFields(value) {
+  const invoice = lightningValue(value);
+  if (!invoice)
+    return null;
+  try {
+    const decoded = import_bech322.bech32.decode(lowerText(invoice), 5000);
+    if (decoded.words.length < 7 + 104)
+      return null;
+    const timestampSeconds = wordsValue(decoded.words.slice(0, 7));
+    if (timestampSeconds == null)
+      return null;
+    return {
+      invoice,
+      timestampSeconds,
+      taggedFields: decoded.words.slice(7, -104)
+    };
+  } catch {
+    return null;
+  }
+}
+function readTaggedField(words, expectedTag) {
+  let offset = 0;
+  while (offset + 3 <= words.length) {
+    const tag = words[offset];
+    const length = words[offset + 1] * 32 + words[offset + 2];
+    const start = offset + 3;
+    const end = start + length;
+    if (end > words.length)
+      return null;
+    if (tag === expectedTag)
+      return words.slice(start, end);
+    offset = end;
+  }
+  return;
+}
+function getLightningInvoiceAmountMsats(invoice) {
+  const value = lowerText(invoice);
+  const match = value.match(/^ln(?:bcrt|bc|tb|sb|tbs)(\d+[munp]?)?1/);
+  const amount = match?.[1];
+  if (!amount)
+    return null;
+  const unit = /[munp]$/.test(amount) ? amount.slice(-1) : "";
+  const raw = unit ? amount.slice(0, -1) : amount;
+  if (!/^\d+$/.test(raw))
+    return null;
+  const n = BigInt(raw);
+  switch (unit) {
+    case "m":
+      return n * 100000000n;
+    case "u":
+      return n * 100000n;
+    case "n":
+      return n * 100n;
+    case "p":
+      return n % 10n === 0n ? n / 10n : null;
+    default:
+      return n * 100000000000n;
+  }
+}
+function lightningAmountSats(invoice) {
+  const amountMsats = getLightningInvoiceAmountMsats(invoice);
+  return amountMsats == null ? null : ceilDiv(amountMsats, 1000n);
+}
+function getLightningInvoiceExpiresAtMs(value) {
+  const fields = lightningFields(value);
+  if (!fields)
+    return null;
+  const expiryWords = readTaggedField(fields.taggedFields, 6);
+  if (expiryWords === null)
+    return null;
+  const expirySeconds = expiryWords === undefined ? 3600 : wordsValue(expiryWords);
+  if (expirySeconds == null)
+    return null;
+  const expiresAtMs = (fields.timestampSeconds + expirySeconds) * 1000;
+  return Number.isSafeInteger(expiresAtMs) ? expiresAtMs : null;
+}
+function readLightningInvoice(value) {
+  const invoice = lightningValue(value);
+  if (!invoice)
+    return null;
+  const amountSats = lightningAmountSats(invoice);
+  return {
+    type: externalInvoiceType.lightning,
+    invoice,
+    ...amountSats != null && amountSats > 0n ? { amount: amountSats.toString() } : {}
+  };
+}
+function getLightningInvoiceNetwork(value) {
+  const lower = lowerText(readLightningInvoice(value)?.invoice);
+  if (!lower)
+    return null;
+  if (lower.startsWith("lnbcrt"))
+    return "REGTEST";
+  if (lower.startsWith("lntbs") || lower.startsWith("lnsb"))
+    return "SIGNET";
+  if (lower.startsWith("lntb"))
+    return "TESTNET";
+  if (lower.startsWith("lnbc"))
+    return "MAINNET";
+  return null;
+}
+
+// ../../core/paymentrequest.js
+"use client";
+var PUBLIC_PAYMENT_REQUEST_VERSION = "1";
+var PUBLIC_PAYMENT_REQUEST_PATH = "/pay/";
+var PUBLIC_PAYMENT_REQUEST_EXPIRY_SECONDS = 24 * 60 * 60;
+var PUBLIC_PAYMENT_REQUEST_MAX_EXPIRY_SECONDS = 7 * 24 * 60 * 60;
+var REQUEST_ID_RE = /^[0-9a-f]{64}$/u;
+var UID_RE = /^[A-Za-z0-9_-]{1,128}$/u;
+var WALLET_PK_RE = /^(02|03)[0-9a-f]{64}$/u;
+var SIGNING_PK_RE = /^[0-9a-f]{64}$/u;
+var SIGNATURE_RE2 = /^[0-9a-f]{128}$/u;
+var INTEGER_RE = /^[1-9][0-9]*$/u;
+var ALLOWED_HOSTS = new Set([
+  new URL(origins.veyl).hostname,
+  new URL(origins.veylDev).hostname
+]);
+function cleanString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+function cleanHex(value) {
+  return cleanString(value).toLowerCase();
+}
+function cleanIntegerString(value) {
+  const text = cleanString(typeof value === "bigint" || typeof value === "number" ? String(value) : value);
+  if (!INTEGER_RE.test(text))
+    return null;
+  const number = Number(text);
+  return Number.isSafeInteger(number) && number > 0 ? text : null;
+}
+function cleanRequestData(value = {}) {
+  const v = cleanString(value.v);
+  const id = cleanHex(value.id);
+  const uid = cleanString(value.uid);
+  const username = normalizeUsername(value.username);
+  const walletPK = cleanHex(value.walletPK);
+  const signingPK = cleanHex(value.signingPK);
+  const amount = cleanIntegerString(value.amount);
+  const invoice = readLightningInvoice(value.invoice)?.invoice?.toLowerCase() || "";
+  const expiresAt = cleanIntegerString(value.expiresAt);
+  let network;
+  try {
+    network = normalizeWalletNetwork(value.network);
+  } catch {
+    return null;
+  }
+  if (v !== PUBLIC_PAYMENT_REQUEST_VERSION || !REQUEST_ID_RE.test(id) || !UID_RE.test(uid) || !isUsername(username) || !WALLET_PK_RE.test(walletPK) || !SIGNING_PK_RE.test(signingPK) || !amount || !invoice || !expiresAt || getLightningInvoiceNetwork(invoice) !== network || readLightningInvoice(invoice)?.amount !== amount || String(Math.floor((getLightningInvoiceExpiresAtMs(invoice) || 0) / 1000)) !== expiresAt) {
+    return null;
+  }
+  return {
+    v,
+    id,
+    uid,
+    username,
+    walletPK,
+    signingPK,
+    network,
+    amount,
+    invoice,
+    expiresAt
+  };
+}
+function publicPaymentRequestSigningBytes(value) {
+  const data = cleanRequestData(value);
+  if (!data)
+    throw new Error("invalid public payment request");
+  return encoder.encode([
+    "veyl-public-payment-request-v1",
+    data.id,
+    data.uid,
+    data.username,
+    data.walletPK,
+    data.signingPK,
+    data.network,
+    data.amount,
+    data.invoice,
+    data.expiresAt
+  ].join(`
+`));
+}
+function createPublicPaymentRequest(value = {}) {
+  const signingKey = value.signingKey;
+  const signingPK = cleanHex(signingKey?.publicKey);
+  const invoiceExpiryMs = getLightningInvoiceExpiresAtMs(value.invoice);
+  const data = cleanRequestData({
+    v: PUBLIC_PAYMENT_REQUEST_VERSION,
+    id: value.id || toHex(randomBytes3(32)),
+    uid: value.uid,
+    username: value.username,
+    walletPK: value.walletPK,
+    signingPK,
+    network: value.network,
+    amount: value.amountSats,
+    invoice: value.invoice,
+    expiresAt: invoiceExpiryMs ? String(Math.floor(invoiceExpiryMs / 1000)) : ""
+  });
+  if (!data)
+    throw new Error("invalid public payment request");
+  if (Number(data.expiresAt) * 1000 <= Number(value.nowMs ?? Date.now())) {
+    throw new Error("public payment request invoice expired");
+  }
+  return Object.freeze({
+    ...data,
+    sig: signChatBytes(signingKey, publicPaymentRequestSigningBytes(data))
+  });
+}
+function verifyPublicPaymentRequest(value) {
+  const data = cleanRequestData(value);
+  const sig = cleanHex(value?.sig);
+  if (!data || !SIGNATURE_RE2.test(sig))
+    return null;
+  if (!verifyChatBytes(data.signingPK, sig, publicPaymentRequestSigningBytes(data)))
+    return null;
+  return Object.freeze({ ...data, sig });
+}
+function encodePublicPaymentRequest(value) {
+  const request = verifyPublicPaymentRequest(value);
+  if (!request)
+    throw new Error("verified public payment request required");
+  return bytesBase64Url(encoder.encode(JSON.stringify(request)));
+}
+function makePublicPaymentLink(value, options = {}) {
+  const origin = cleanString(options.origin) || origins.veyl;
+  const parsedOrigin = new URL(origin);
+  if (parsedOrigin.protocol !== "https:" || !ALLOWED_HOSTS.has(parsedOrigin.hostname)) {
+    throw new Error("invalid public payment origin");
+  }
+  return `${parsedOrigin.origin}${PUBLIC_PAYMENT_REQUEST_PATH}${encodePublicPaymentRequest(value)}`;
 }
 
 // ../../core/wallet/bitcoin.js
@@ -34104,7 +35646,7 @@ function createPeersApi({ cloud, network, avatarCache = null }) {
     if (!uid || expectedVersion == null || typeof avatarCache?.read !== "function")
       return null;
     try {
-      const cached = await avatarCache.read(uid);
+      const cached = await avatarCache.read(uid, expectedVersion);
       const version = readAvatarVersion(cached?.version);
       const url = typeof cached?.url === "string" && cached.url ? cached.url : typeof cached?.source === "string" && cached.source ? cached.source : null;
       return version === expectedVersion && url ? url : null;
@@ -41605,8 +43147,6 @@ function requirePorts(options) {
     throw new Error("account cloud port required");
   if (!options?.defaultNetwork)
     throw new Error("account default network required");
-  if (typeof options?.setNetwork !== "function")
-    throw new Error("account network port required");
   if (!options?.vaultCrypto)
     throw new Error("account vault crypto port required");
   if (typeof options?.bootWallet !== "function")
@@ -41642,8 +43182,7 @@ function openAccount(options = {}) {
     vaultCrypto,
     bootWallet,
     bootChat,
-    openLocalCache,
-    setNetwork: writeNetwork
+    openLocalCache
   } = ports;
   let closed = false;
   let attempt = 0;
@@ -41653,26 +43192,46 @@ function openAccount(options = {}) {
   let closePromise = null;
   let state;
   let chatSession = null;
+  let revokedUid = null;
+  let revocationPromise = null;
   let nextAgreement = agreementContract(options.agreement || CURRENT_AGREEMENT);
   const listeners = new Set;
   let activeWriteTail = Promise.resolve();
   const sessionCloseWork = new Set;
   const operationBarrier = createAccountOperationCloseBarrier();
+  const messageMaintenance = createAccountMessageMaintenance({
+    isAccountCurrent: () => !closed
+  });
+  function revokeSession(details = {}) {
+    const { uid = null } = details;
+    const accountUid = uid || state?.uid || null;
+    if (accountUid && revokedUid === accountUid) {
+      return revocationPromise || Promise.resolve();
+    }
+    revokedUid = accountUid;
+    let callback;
+    try {
+      callback = options.onSessionRevoked?.({ ...details, uid: accountUid });
+    } catch (error) {
+      callback = Promise.reject(error);
+    }
+    lock();
+    revocationPromise = Promise.resolve(callback);
+    return revocationPromise;
+  }
   const user = options.user || createUser({
     cloud,
     network: options.network || defaultNetwork,
     avatarCache,
     diag,
-    onSessionRevoked: ({ uid } = {}) => {
-      lock();
-      options.onSessionRevoked?.({ uid: uid || state?.uid || null });
-    }
+    onSessionRevoked: revokeSession
   });
   state = emptyState(user.getSnapshot(), options.network || defaultNetwork);
   const chat = createChatSession({
     ...options.chat || {},
     cloud,
-    diag: options.chat?.diag || diag
+    diag: options.chat?.diag || diag,
+    maintenance: messageMaintenance
   }, chatSources());
   const wallet = openWallet({
     ...options.wallet || {},
@@ -41701,6 +43260,7 @@ function openAccount(options = {}) {
       chatPrivateKey: session?.chatPrivateKey || "",
       notificationPK: session?.notificationPK || "",
       notificationPrivateKey: session?.notificationPrivateKey || "",
+      chatAdmission: currentUser.chatAdmission,
       localCache: session?.localCache || null
     };
   }
@@ -41780,6 +43340,15 @@ function openAccount(options = {}) {
       await cloud.user.profile.avatar.set(uid, null);
       user.getSnapshot().clearAvatar?.();
       return { deleted: true };
+    },
+    async setChatAdmission(options2 = {}) {
+      const uid = profileUid();
+      const session = state.session;
+      if (!session?.chatPrivateKey || !session?.chatPK)
+        throw new Error("vault must be unlocked");
+      const chatAdmission = makeChatAdmission(session.chatPrivateKey, session.chatPK, options2);
+      await cloud.user.profile.admission.set(uid, chatAdmission);
+      return chatAdmission;
     }
   });
   const push = Object.freeze({
@@ -41792,6 +43361,56 @@ function openAccount(options = {}) {
       return cloud.user.push.drop(payload);
     }
   });
+  const payment = Object.freeze({
+    async createRequest(options2 = {}) {
+      const amountSats = toSafeSats(options2.amountSats);
+      if (BigInt(amountSats) > REQUEST_MONEY_MAX_SATS) {
+        throw new Error("payment request amount too large");
+      }
+      const expirySeconds = options2.expirySeconds == null ? PUBLIC_PAYMENT_REQUEST_EXPIRY_SECONDS : Number(options2.expirySeconds);
+      if (!Number.isSafeInteger(expirySeconds) || expirySeconds < 60 || expirySeconds > PUBLIC_PAYMENT_REQUEST_MAX_EXPIRY_SECONDS) {
+        throw new Error("payment request expiry must be between one minute and seven days");
+      }
+      const uid = profileUid();
+      const session = state.session;
+      const username = normalizeUsername(state.user?.username);
+      const walletPK = session?.walletPK;
+      const signingKey = session?.chatSigningSecret && session?.chatSigningPK ? { secret: session.chatSigningSecret, publicKey: session.chatSigningPK } : null;
+      if (state.lockState !== "unlocked" || !session || session.closed) {
+        throw new Error("unlocked vault required");
+      }
+      if (!isUsername(username) || !walletPK || !signingKey) {
+        throw new Error("payment request identity unavailable");
+      }
+      const createInvoice = wallet.getSnapshot().value.createLightningInvoice;
+      const result = await createInvoice({
+        amountSats,
+        expirySeconds,
+        includeSparkInvoice: true
+      });
+      if (closed || operationBarrier.blocksOperations || state.uid !== uid || state.session !== session || session.closed) {
+        throw new Error("account changed during payment request");
+      }
+      if (!result?.success || !result.invoice?.encodedInvoice) {
+        throw result?.error || new Error("lightning invoice unavailable");
+      }
+      const request = createPublicPaymentRequest({
+        uid,
+        username,
+        walletPK,
+        signingKey,
+        network: session.network || state.network,
+        amountSats,
+        invoice: result.invoice.encodedInvoice
+      });
+      const origin = cloud.environment === "dev" ? origins.veylDev : origins.veyl;
+      return Object.freeze({
+        request,
+        link: makePublicPaymentLink(request, { origin }),
+        receiveRequest: result.invoice
+      });
+    }
+  });
   function emit2(patch) {
     if (closed || operationBarrier.suppressPublications)
       return state;
@@ -41849,7 +43468,13 @@ function openAccount(options = {}) {
     chatSession = null;
     closeAccountSession(session);
     if (session && typeof options.onSessionClosed === "function") {
-      const work = Promise.resolve().then(() => options.onSessionClosed({ session, uid: state.uid })).catch((error) => {
+      let result;
+      try {
+        result = options.onSessionClosed({ session, uid: state.uid });
+      } catch (error) {
+        result = Promise.reject(error);
+      }
+      const work = Promise.resolve(result).catch((error) => {
         diag?.("account.session.closed.error", {
           code: error?.code || "",
           message: error?.message || String(error)
@@ -41875,13 +43500,17 @@ function openAccount(options = {}) {
     }
     return session;
   }
+  async function drainSessionCloseWork() {
+    while (sessionCloseWork.size) {
+      await Promise.allSettled([...sessionCloseWork]);
+    }
+  }
   function lock() {
     const session = closeSession();
     setActive(false);
     return session;
   }
   async function applyNetwork(network) {
-    await writeNetwork(network);
     user.setNetwork(network);
     emitDomains({ network });
     peers.refreshNetwork();
@@ -41915,6 +43544,24 @@ function openAccount(options = {}) {
         code: error?.code || "",
         message: error?.message || String(error)
       });
+      if (isAccountAuthenticationError(error)) {
+        revokeSession({
+          uid,
+          code: error?.code || "",
+          reason: "vault-listener"
+        }).catch((revocationError) => {
+          diag?.("account.session.revoke.error", {
+            code: revocationError?.code || "",
+            message: revocationError?.message || String(revocationError)
+          });
+        }).then(() => cloud.auth.logout()).catch((logoutError) => {
+          diag?.("account.session.revoke.auth.error", {
+            code: logoutError?.code || "",
+            message: logoutError?.message || String(logoutError)
+          });
+        });
+        return;
+      }
       lock();
       emit2({ vault: null, vaultReady: true, vaultError: error });
     });
@@ -41946,7 +43593,6 @@ function openAccount(options = {}) {
         writeActive(previousUid, false);
       active = { uid: null, value: false };
       user.setNetwork(defaultNetwork);
-      Promise.resolve(writeNetwork(defaultNetwork)).catch(() => {});
       const currentUser = user.getSnapshot();
       const currentUid = currentUser.uid || null;
       state = {
@@ -41964,6 +43610,11 @@ function openAccount(options = {}) {
   const stopUser = user.subscribe(syncUser);
   watchVault(state.uid);
   async function unlock(password, unlockOptions = {}) {
+    if (closed)
+      throw new Error("account closed");
+    if (state.lockState !== "locked")
+      throw new Error("unlock in progress");
+    await drainSessionCloseWork();
     if (closed)
       throw new Error("account closed");
     if (state.lockState !== "locked")
@@ -42307,10 +43958,12 @@ function openAccount(options = {}) {
     user,
     profile,
     push,
+    payment,
     support,
     chat,
     wallet,
     bitcoin,
+    messageMaintenance,
     peers,
     closeBarrier: Object.freeze({
       acquire: operationBarrier.acquireClose,