@glyphteck/veyl 0.59.1 → 0.61.0

package/dist/cli.js

@@ -6451,7 +6451,7 @@ var init_notifications = __esm(() => {
 });
 
 // ../../core/config.js
-var MS_PER_SECOND = 1000, MINUTE_MS, HOUR_MS, DAY_MS, KIB_BYTES = 1024, MIB_BYTES, SATS_PER_BITCOIN = 100000000n, USERNAME_MAX_CHARS = 12, PASSWORD_MIN_CHARS = 15, PASSWORD_MAX_CHARS = 64, PASSWORD_MAX_BYTES, AUTOLOCK_MIN_MINUTES = 1, AUTOLOCK_MAX_MINUTES = 60, LOCAL_CACHE_WRITE_DELAY_MS = 350, LOCAL_MEDIA_CACHE_MAX_BYTES, LOCAL_MEDIA_CACHE_MAX_ITEMS = 1000, LOCAL_MEDIA_ACCESS_TOUCH_MIN_MS, LOCAL_PROFILE_CACHE_MAX_ITEMS = 500, LOCAL_PROFILE_CACHE_MAX_AGE_MS, LOCAL_CHAT_CACHE_MAX_ITEMS = 1000, LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000, LOCAL_CHAT_MESSAGE_CACHE_WRITE_DELAY_MS = 2500, LOCAL_AVATAR_CACHE_MAX_BYTES, LOCAL_AVATAR_CACHE_MAX_AGE_MS, AVATAR_IMAGE_MAX_BYTES, CHAT_AVATAR_IMAGE_MAX_BYTES, CHAT_AVATAR_REF_MAX_CHARS, CHAT_MESSAGE_FILE_CACHE_MAX_BYTES, IDLE_CALLBACK_MIN_TIMEOUT_MS = 50, ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500, ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250, CHAT_UNSAVED_TTL_DAYS = 21, CHAT_UNSAVED_TTL_MS, CHAT_AFTER_SEEN_MS, CHAT_MEDIA_TTL_DAYS, CHAT_MEDIA_TTL_MS, CHAT_UPLOAD_MAX_BYTES, CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS, CHAT_MESSAGE_BATCH_SIZE = 40, CHAT_MESSAGE_QUERY_MAX_DOCS = 120, CHAT_TTL_CLIENT_DELETE_GRACE_MS, CHAT_TTL_DELETE_CHUNK_SIZE = 40, CHAT_DELETE_SCAN_BATCH_SIZE = 200, CHAT_DELETE_WRITE_BATCH_SIZE = 400, CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500, CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250, CHAT_LIST_PAGE_SIZE = 20, CHAT_LIST_LIVE_COUNT, CHAT_INBOX_PING_PAGE_SIZE = 25, CHAT_INBOX_CURSOR_OVERLAP_MS, CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500, CHAT_LIST_SNAPSHOT_COALESCE_MS = 80, CHAT_LIST_LISTENER_RETRY_MS = 1000, CHAT_TOP_WARM_COUNT = 0, CHAT_EAGER_WARM_COUNT = 0, CHAT_WARM_DELAY_MS = 3000, CHAT_WARM_BATCH_SIZE, CHAT_MESSAGE_VIEW_CACHE_SIZE = 30, CHAT_MEDIA_WARM_MESSAGES_PER_CHAT, CHAT_MEDIA_WARM_START_DELAY_MS = 600, CHAT_MEDIA_WARM_STEP_DELAY_MS = 120, CHAT_MEDIA_WARM_TYPES, CHAT_MEDIA_WARM_MAX_BYTES = 0, CHAT_READ_WRITE_INTERVAL_MS, CHAT_READ_WRITE_MAX_WAIT_MS, CHAT_LIVE_PING_INTERVAL_MS, CHAT_LIVE_SWEEP_INTERVAL_MS, CHAT_LIVE_STALE_AFTER_MS, CHAT_LIVE_RECONNECT_MAX_MS, CHAT_LIVE_TYPING_IDLE_MS, CHAT_LIVE_TYPING_RENEW_MS, CHAT_LIVE_COMPOSITION_HANDOFF_MS, CHAT_LIVE_READ_SEND_INTERVAL_MS = 120, CHAT_LIVE_READ_SEND_MAX_WAIT_MS = 500, CHAT_LIVE_READ_WRITE_INTERVAL_MS, CHAT_LIVE_READ_WRITE_MAX_WAIT_MS, CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12, CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS, CHAT_SETTINGS_BODY_MAX_BYTES, CHAT_MANIFEST_MAX_BYTES, CHAT_RECEIPT_MAX_MEMBERS = 32, CHAT_ORDINARY_DELIVERY_MAX_MEMBERS = 128, CHAT_MAX_MEMBERS = 256, CHAT_MAX_TEXT_CHARS = 2048, CHAT_MAX_REACTIONS, SEARCH_DEBOUNCE_MS = 300, SEARCH_USERNAME_LIMIT = 15, SEARCH_ROLE_LIMIT = 15, RECENT_PEER_REFRESH_LIMIT = 50, RECENT_PEER_REFRESH_DELAY_MS = 250, RECENT_PEER_REFRESH_INTERVAL_MS, RECENT_PEER_REFRESH_THROTTLE_MS = 120, BAN_REFRESH_GRACE_MS = 50, REQUEST_MONEY_MAX_SATS, WALLET_TRANSFER_POLL_MS, WALLET_ACTIVE_TRANSFER_REFRESH_MS, WALLET_IDLE_ACTIVE_TRANSFER_REFRESH_MS, WALLET_VISIBLE_TRANSFER_DISCOVERY_WINDOW_MS, WALLET_ACTIVE_TRANSFER_EMPTY_SCAN_LIMIT = 8, WALLET_CACHE_HYDRATE_DELAY_MS = 0, WALLET_BOOT_REFRESH_DELAY_MS = 500, WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500, WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS, WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS, WALLET_BALANCE_EVENT_COALESCE_MS, WALLET_INCOMING_UPDATE_COALESCE_MS = 250, WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000, WALLET_CLAIM_PAGE_SIZE = 100, WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2, WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3, WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS, WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS, WALLET_SDK_BACKGROUND_QUIET_MS, WALLET_RECENT_TRANSFER_LIMIT = 100, WALLET_TRANSFER_PAGE_LIMIT = 100, WALLET_TRANSFER_FETCH_THROTTLE_MS = 150, WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS, WALLET_SENT_TRANSFER_REFRESH_DELAY_MS, WALLET_PENDING_TRANSFER_BOOT_GRACE_MS, WALLET_PENDING_TRANSFER_HOT_AGE_MS, WALLET_PENDING_TRANSFER_WARM_AGE_MS, WALLET_PENDING_TRANSFER_WARM_RETRY_MS, WALLET_PENDING_TRANSFER_STALE_RETRY_MS, WALLET_PENDING_TRANSFER_STUCK_RETRY_MS, WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS, WALLET_TRANSFER_CACHE_WRITE_DELAY_MS;
+var MS_PER_SECOND = 1000, MINUTE_MS, HOUR_MS, DAY_MS, KIB_BYTES = 1024, MIB_BYTES, SATS_PER_BITCOIN = 100000000n, USERNAME_MAX_CHARS = 12, PASSWORD_MIN_CHARS = 15, PASSWORD_MAX_CHARS = 64, PASSWORD_MAX_BYTES, AUTOLOCK_MIN_MINUTES = 1, AUTOLOCK_MAX_MINUTES = 60, LOCAL_CACHE_WRITE_DELAY_MS = 350, LOCAL_MEDIA_CACHE_MAX_BYTES, LOCAL_MEDIA_CACHE_MAX_ITEMS = 1000, LOCAL_MEDIA_ACCESS_TOUCH_MIN_MS, LOCAL_PROFILE_CACHE_MAX_ITEMS = 500, LOCAL_PROFILE_CACHE_MAX_AGE_MS, LOCAL_CHAT_CACHE_MAX_ITEMS = 1000, LOCAL_CHAT_MESSAGE_CACHE_MAX_VISIBLE = 1000, LOCAL_CHAT_MESSAGE_CACHE_WRITE_DELAY_MS = 2500, LOCAL_AVATAR_CACHE_MAX_BYTES, LOCAL_AVATAR_CACHE_MAX_AGE_MS, AVATAR_IMAGE_MAX_BYTES, AVATAR_IMAGE_QUALITY_ATTEMPTS, CHAT_AVATAR_IMAGE_MAX_BYTES, CHAT_AVATAR_REF_MAX_CHARS = 256, CHAT_MESSAGE_FILE_CACHE_MAX_BYTES, IDLE_CALLBACK_MIN_TIMEOUT_MS = 50, ATTACHMENT_CACHE_IDLE_TIMEOUT_MS = 2500, ATTACHMENT_CACHE_FALLBACK_DELAY_MS = 250, CHAT_UNSAVED_TTL_DAYS = 21, CHAT_UNSAVED_TTL_MS, CHAT_AFTER_SEEN_MS, CHAT_MEDIA_TTL_DAYS, CHAT_MEDIA_TTL_MS, CHAT_UPLOAD_MAX_BYTES, CHAT_AUDIO_TRANSCODE_BITRATE_BPS = 128000, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS = 3000000, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS, CHAT_MESSAGE_BATCH_SIZE = 40, CHAT_MESSAGE_QUERY_MAX_DOCS = 120, CHAT_TTL_CLIENT_DELETE_GRACE_MS, CHAT_TTL_DELETE_CHUNK_SIZE = 40, CHAT_DELETE_SCAN_BATCH_SIZE = 200, CHAT_DELETE_WRITE_BATCH_SIZE = 400, CHAT_BATCH_CLEANUP_IDLE_TIMEOUT_MS = 1500, CHAT_BATCH_CLEANUP_IDLE_DELAY_MS = 250, CHAT_LIST_PAGE_SIZE = 20, CHAT_LIST_LIVE_COUNT, CHAT_INBOX_PING_PAGE_SIZE = 25, CHAT_INBOX_CURSOR_OVERLAP_MS, CHAT_LIST_CACHE_WRITE_DELAY_MS = 1500, CHAT_LIST_SNAPSHOT_COALESCE_MS = 80, CHAT_LIST_LISTENER_RETRY_MS = 1000, CHAT_TOP_WARM_COUNT = 0, CHAT_EAGER_WARM_COUNT = 0, CHAT_WARM_DELAY_MS = 3000, CHAT_WARM_BATCH_SIZE, CHAT_MESSAGE_VIEW_CACHE_SIZE = 30, CHAT_MEDIA_WARM_MESSAGES_PER_CHAT, CHAT_MEDIA_WARM_START_DELAY_MS = 600, CHAT_MEDIA_WARM_STEP_DELAY_MS = 120, CHAT_MEDIA_WARM_TYPES, CHAT_MEDIA_WARM_MAX_BYTES = 0, CHAT_READ_WRITE_INTERVAL_MS, CHAT_READ_WRITE_MAX_WAIT_MS, CHAT_LIVE_PING_INTERVAL_MS, CHAT_LIVE_SWEEP_INTERVAL_MS, CHAT_LIVE_STALE_AFTER_MS, CHAT_LIVE_RECONNECT_MAX_MS, CHAT_LIVE_TYPING_IDLE_MS, CHAT_LIVE_TYPING_RENEW_MS, CHAT_LIVE_COMPOSITION_HANDOFF_MS, CHAT_LIVE_READ_SEND_INTERVAL_MS = 120, CHAT_LIVE_READ_SEND_MAX_WAIT_MS = 500, CHAT_LIVE_READ_WRITE_INTERVAL_MS, CHAT_LIVE_READ_WRITE_MAX_WAIT_MS, CHAT_SEND_QUEUE_RATE_LIMIT_COUNT = 12, CHAT_SEND_QUEUE_RATE_LIMIT_WINDOW_MS, CHAT_SETTINGS_BODY_MAX_BYTES, CHAT_MANIFEST_MAX_BYTES, CHAT_RECEIPT_MAX_MEMBERS = 32, CHAT_ORDINARY_DELIVERY_MAX_MEMBERS = 128, CHAT_MAX_MEMBERS = 256, CHAT_MAX_TEXT_CHARS = 2048, CHAT_TITLE_MAX_CHARS = 32, CHAT_MAX_REACTIONS, SEARCH_DEBOUNCE_MS = 300, SEARCH_USERNAME_LIMIT = 15, SEARCH_ROLE_LIMIT = 15, RECENT_PEER_REFRESH_LIMIT = 50, RECENT_PEER_REFRESH_DELAY_MS = 250, RECENT_PEER_REFRESH_INTERVAL_MS, RECENT_PEER_REFRESH_THROTTLE_MS = 120, BAN_REFRESH_GRACE_MS = 50, REQUEST_MONEY_MAX_SATS, WALLET_TRANSFER_POLL_MS, WALLET_ACTIVE_TRANSFER_REFRESH_MS, WALLET_IDLE_ACTIVE_TRANSFER_REFRESH_MS, WALLET_VISIBLE_TRANSFER_DISCOVERY_WINDOW_MS, WALLET_ACTIVE_TRANSFER_EMPTY_SCAN_LIMIT = 8, WALLET_CACHE_HYDRATE_DELAY_MS = 0, WALLET_BOOT_REFRESH_DELAY_MS = 500, WALLET_BOOT_CACHED_REFRESH_DELAY_MS = 2500, WALLET_REGTEST_DEPOSIT_CLAIM_POLL_MS, WALLET_MAINNET_DEPOSIT_CLAIM_POLL_MS, WALLET_BALANCE_EVENT_COALESCE_MS, WALLET_INCOMING_UPDATE_COALESCE_MS = 250, WALLET_AUTO_CLAIM_MAX_FEE_SATS = 5000, WALLET_CLAIM_PAGE_SIZE = 100, WALLET_PENDING_TRANSFER_CLAIM_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_STATUS_BATCH_SIZE = 2, WALLET_PENDING_TRANSFER_COLD_REFRESH_BATCH_SIZE = 50, WALLET_PENDING_TRANSFER_COLD_REFRESH_INTERVAL_MS, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_QUEUE = 3, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_QUEUE = 10, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_SMALL_SIZE = 2, WALLET_PENDING_TRANSFER_ADAPTIVE_BATCH_LARGE_SIZE = 3, WALLET_PENDING_TRANSFER_SLOW_CLAIM_MS, WALLET_PENDING_TRANSFER_CLAIM_COOLDOWN_MS, WALLET_SDK_BACKGROUND_QUIET_MS, WALLET_RECENT_TRANSFER_LIMIT = 100, WALLET_TRANSFER_PAGE_LIMIT = 100, WALLET_TRANSFER_FETCH_THROTTLE_MS = 150, WALLET_PENDING_TRANSFER_CLAIM_RETRY_MS, WALLET_SENT_TRANSFER_REFRESH_DELAY_MS, WALLET_PENDING_TRANSFER_BOOT_GRACE_MS, WALLET_PENDING_TRANSFER_HOT_AGE_MS, WALLET_PENDING_TRANSFER_WARM_AGE_MS, WALLET_PENDING_TRANSFER_WARM_RETRY_MS, WALLET_PENDING_TRANSFER_STALE_RETRY_MS, WALLET_PENDING_TRANSFER_STUCK_RETRY_MS, WALLET_PENDING_TRANSFER_DORMANT_RETRY_MS, WALLET_TRANSFER_CACHE_WRITE_DELAY_MS;
 var init_config = __esm(() => {
   MINUTE_MS = 60 * MS_PER_SECOND;
   HOUR_MS = 60 * MINUTE_MS;
@@ -6464,8 +6464,8 @@ var init_config = __esm(() => {
   LOCAL_AVATAR_CACHE_MAX_BYTES = 128 * MIB_BYTES;
   LOCAL_AVATAR_CACHE_MAX_AGE_MS = 30 * DAY_MS;
   AVATAR_IMAGE_MAX_BYTES = 256 * KIB_BYTES;
-  CHAT_AVATAR_IMAGE_MAX_BYTES = 16 * KIB_BYTES;
-  CHAT_AVATAR_REF_MAX_CHARS = 24 * KIB_BYTES;
+  AVATAR_IMAGE_QUALITY_ATTEMPTS = Object.freeze([0.92, 0.84, 0.76, 0.68]);
+  CHAT_AVATAR_IMAGE_MAX_BYTES = AVATAR_IMAGE_MAX_BYTES;
   CHAT_MESSAGE_FILE_CACHE_MAX_BYTES = 64 * MIB_BYTES;
   CHAT_UNSAVED_TTL_MS = CHAT_UNSAVED_TTL_DAYS * DAY_MS;
   CHAT_AFTER_SEEN_MS = DAY_MS;
@@ -9425,6 +9425,430 @@ var init_user = __esm(() => {
   };
 });
 
+// ../../core/crypto/file.js
+function createFileKey() {
+  return randomBytes3(32);
+}
+function encodeFileKey(key) {
+  return toHex(toBytes32(key, "file key"));
+}
+function decodeFileKey(key) {
+  return toBytes32(key, "file key");
+}
+function getFileAadForPath(scope) {
+  if (!scope) {
+    throw new Error("file scope required");
+  }
+  return encodeScope(FILE_SCOPE, [scope]);
+}
+function getSubtleCrypto() {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) {
+    throw new Error("WebCrypto AES-GCM unavailable");
+  }
+  return subtle;
+}
+async function importAesKey(key, usages) {
+  return getSubtleCrypto().importKey("raw", toBytes32(key, "file key"), { name: "AES-GCM" }, false, usages);
+}
+async function sealFile(key, bytes, scope) {
+  const fileKey = new Uint8Array(toBytes32(key, "file key"));
+  try {
+    const cryptoKey = await importAesKey(fileKey, ["encrypt"]);
+    const iv = randomBytes3(FILE_IV_BYTES);
+    const ct = await getSubtleCrypto().encrypt({
+      name: "AES-GCM",
+      iv,
+      tagLength: FILE_TAG_BYTES * 8,
+      additionalData: getFileAadForPath(scope)
+    }, cryptoKey, toBytes(bytes, "plaintext"));
+    return packBodyData(iv, new Uint8Array(ct));
+  } finally {
+    cleanBytes(fileKey);
+  }
+}
+async function openFileForPath(key, body, scope) {
+  const fileKey = new Uint8Array(toBytes32(key, "file key"));
+  try {
+    const cryptoKey = await importAesKey(fileKey, ["decrypt"]);
+    const { nonce, ct } = unpackBodyData(body, FILE_IV_BYTES);
+    const pt = await getSubtleCrypto().decrypt({
+      name: "AES-GCM",
+      iv: nonce,
+      tagLength: FILE_TAG_BYTES * 8,
+      additionalData: getFileAadForPath(scope)
+    }, cryptoKey, ct);
+    return new Uint8Array(pt);
+  } finally {
+    cleanBytes(fileKey);
+  }
+}
+var FILE_SCOPE = "file-body", FILE_IV_BYTES = 12, FILE_TAG_BYTES = 16;
+var init_file = __esm(() => {
+  init_core();
+  init_kdf();
+  init_pack();
+  "use client";
+});
+
+// ../../core/chat/filepayload.js
+function cleanMediaEpochId(value) {
+  const epochId = String(value || "").trim();
+  if (!new RegExp(`^${CHAT_ID_PATTERN}$`).test(epochId)) {
+    throw new Error("invalid media epoch id");
+  }
+  return epochId.toLowerCase();
+}
+function cleanMediaId(value) {
+  const mediaId = String(value || "").trim();
+  if (!new RegExp(`^${MEDIA_ID_PATTERN}$`).test(mediaId)) {
+    throw new Error("invalid media id");
+  }
+  return mediaId.toLowerCase();
+}
+function cleanSharedMediaId(value) {
+  const sharedId = String(value || "").trim();
+  if (!new RegExp(`^${SHARED_MEDIA_ID_PATTERN}$`).test(sharedId)) {
+    throw new Error("invalid shared media id");
+  }
+  return sharedId.toLowerCase();
+}
+function makeChatMediaId() {
+  return toHex(randomBytes3(16));
+}
+function mediaFilePath(epochId, mediaId) {
+  const nextEpochId = cleanMediaEpochId(epochId);
+  const nextMediaId = cleanMediaId(mediaId);
+  return `${CHAT_MEDIA_ROOT}/${nextEpochId}/${nextMediaId}`;
+}
+function sharedMediaFilePath(sharedId) {
+  const nextSharedId = cleanSharedMediaId(sharedId);
+  return `${SHARED_MEDIA_ROOT}/${nextSharedId}`;
+}
+function makeSharedMediaId() {
+  return toHex(randomBytes3(16));
+}
+function getMediaFileRef(path) {
+  const value = String(path || "").trim();
+  const chatMatch = value.match(CHAT_MEDIA_FILE_PATTERN);
+  if (chatMatch?.[1] && chatMatch?.[2]) {
+    return {
+      type: "chat",
+      epochId: chatMatch[1].toLowerCase(),
+      mediaId: chatMatch[2].toLowerCase()
+    };
+  }
+  const sharedMatch = value.match(SHARED_MEDIA_FILE_PATTERN);
+  if (sharedMatch?.[1]) {
+    return {
+      type: "shared",
+      sharedId: sharedMatch[1].toLowerCase()
+    };
+  }
+  throw new Error("invalid media file path");
+}
+function getChatMediaFileRef(path) {
+  const ref = getMediaFileRef(path);
+  if (ref?.type !== "chat") {
+    throw new Error("invalid media file path");
+  }
+  return ref;
+}
+function getSharedMediaFileRef(path) {
+  const ref = getMediaFileRef(path);
+  if (ref?.type !== "shared") {
+    throw new Error("invalid shared media file path");
+  }
+  return ref;
+}
+function uploadByteLength(value) {
+  if (Number.isFinite(value?.byteLength)) {
+    return value.byteLength;
+  }
+  if (Number.isFinite(value?.size)) {
+    return value.size;
+  }
+  if (Number.isFinite(value)) {
+    return value;
+  }
+  return null;
+}
+function makeChatUploadTooLargeError(bytes, maxBytes = MAX_CHAT_UPLOAD_BYTES) {
+  const error = new Error("upload too large");
+  error.code = "upload-too-large";
+  error.maxBytes = maxBytes;
+  if (Number.isFinite(bytes)) {
+    error.bytes = bytes;
+  }
+  return error;
+}
+function assertChatUploadByteSize(bytes, maxBytes = MAX_CHAT_UPLOAD_BYTES) {
+  const length = uploadByteLength(bytes);
+  if (!Number.isFinite(length)) {
+    throw new Error("upload bytes required");
+  }
+  if (length <= 0 || length > maxBytes) {
+    throw makeChatUploadTooLargeError(length, maxBytes);
+  }
+  return length;
+}
+async function toUploadBytes(data) {
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    if (typeof data.arrayBuffer === "function") {
+      return new Uint8Array(await data.arrayBuffer());
+    }
+    if (typeof FileReader !== "undefined") {
+      return new Promise((resolve, reject) => {
+        const reader = new FileReader;
+        reader.onload = () => resolve(new Uint8Array(reader.result));
+        reader.onerror = () => reject(reader.error || new Error("blob read failed"));
+        reader.readAsArrayBuffer(data);
+      });
+    }
+    if (typeof Response !== "undefined") {
+      return new Uint8Array(await new Response(data).arrayBuffer());
+    }
+  }
+  if (typeof data?.arrayBuffer === "function") {
+    return new Uint8Array(await data.arrayBuffer());
+  }
+  return toBytes(data, "upload bytes");
+}
+async function makeChatFileUploadPayload(epochId, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
+  const nextEpochId = cleanMediaEpochId(epochId);
+  const mediaId = makeChatMediaId();
+  const path = mediaFilePath(nextEpochId, mediaId);
+  const expiresAt = Date.now() + CHAT_MEDIA_TTL_MS2;
+  const key = createFileKey();
+  try {
+    const uploadBytes = await toUploadBytes(data);
+    assertChatUploadByteSize(uploadBytes);
+    const body = await sealFile(key, uploadBytes, path);
+    assertChatUploadByteSize(body);
+    return {
+      epochId: nextEpochId,
+      mediaId,
+      path,
+      body,
+      metadata: {
+        contentType: "application/octet-stream",
+        cacheControl
+      },
+      file: {
+        p: path,
+        k: encodeFileKey(key),
+        x: expiresAt
+      }
+    };
+  } catch (error) {
+    if (error && typeof error === "object") {
+      error.path = error?.path || path;
+      error.cid = error?.cid || cid;
+    }
+    throw error;
+  } finally {
+    cleanBytes(key);
+  }
+}
+async function makeSharedFileUploadPayload(data, { contentType = "application/octet-stream", cacheControl = "private, max-age=0, no-transform" } = {}) {
+  const sharedId = makeSharedMediaId();
+  const path = sharedMediaFilePath(sharedId);
+  const expiresAt = Date.now() + CHAT_MEDIA_TTL_MS2;
+  const key = createFileKey();
+  try {
+    const uploadBytes = await toUploadBytes(data);
+    assertChatUploadByteSize(uploadBytes);
+    const body = await sealFile(key, uploadBytes, path);
+    assertChatUploadByteSize(body);
+    return {
+      sharedId,
+      path,
+      body,
+      metadata: {
+        contentType,
+        cacheControl
+      },
+      file: {
+        p: path,
+        k: encodeFileKey(key),
+        x: expiresAt
+      }
+    };
+  } catch (error) {
+    if (error && typeof error === "object") {
+      error.path = error?.path || path;
+      error.sharedId = error?.sharedId || sharedId;
+    }
+    throw error;
+  } finally {
+    cleanBytes(key);
+  }
+}
+var CHAT_MEDIA_ROOT = "chatEpochs", SHARED_MEDIA_ROOT = "shared", CHAT_MEDIA_TTL_MS2, MAX_CHAT_UPLOAD_BYTES, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS2, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS2, CHAT_VIDEO_TRANSCODE_TOTAL_BITRATE_BPS, CHAT_ID_PATTERN = "[0-9a-fA-F]{64}", SHARED_MEDIA_ID_PATTERN = "[0-9a-fA-F]{32}", MEDIA_ID_PATTERN = "[0-9a-fA-F]{32}", CHAT_MEDIA_FILE_PATTERN, SHARED_MEDIA_FILE_PATTERN;
+var init_filepayload = __esm(() => {
+  init_file();
+  init_config();
+  init_core();
+  "use client";
+  CHAT_MEDIA_TTL_MS2 = CHAT_MEDIA_TTL_MS;
+  MAX_CHAT_UPLOAD_BYTES = CHAT_UPLOAD_MAX_BYTES;
+  CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS2 = CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS;
+  CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS2 = CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS;
+  CHAT_VIDEO_TRANSCODE_TOTAL_BITRATE_BPS = CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS2 + CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS2;
+  CHAT_MEDIA_FILE_PATTERN = new RegExp(`^${CHAT_MEDIA_ROOT}/(${CHAT_ID_PATTERN})/(${MEDIA_ID_PATTERN})$`);
+  SHARED_MEDIA_FILE_PATTERN = new RegExp(`^${SHARED_MEDIA_ROOT}/(${SHARED_MEDIA_ID_PATTERN})$`);
+});
+
+// ../../core/files.js
+function makeFileId(size = 8) {
+  return toHex(randomBytes3(size));
+}
+function setErrorStage(error, stage, extra = {}) {
+  if (!error || typeof error !== "object") {
+    return error;
+  }
+  error.stage = error?.stage || stage;
+  Object.assign(error, extra);
+  return error;
+}
+async function makeChatFileUpload(epochId, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
+  try {
+    return await makeChatFileUploadPayload(epochId, cid, data, {
+      cacheControl
+    });
+  } catch (error) {
+    throw setErrorStage(error, "encrypt", {
+      ...error?.path ? { path: error.path } : {},
+      cid
+    });
+  }
+}
+async function putChatFile(epochId, cid, data, options) {
+  const upload = await makeChatFileUpload(epochId, cid, data, options);
+  try {
+    if (typeof options?.uploadChatMedia !== "function") {
+      throw new Error("chat media upload required");
+    }
+    await options.uploadChatMedia(upload);
+    return upload.file;
+  } catch (error) {
+    throw setErrorStage(error, "upload", { path: upload.path, cid });
+  }
+}
+async function makeSharedFileUpload(data, { contentType = "application/octet-stream", cacheControl = "private, max-age=0, no-transform" } = {}) {
+  try {
+    return await makeSharedFileUploadPayload(data, {
+      contentType,
+      cacheControl
+    });
+  } catch (error) {
+    throw setErrorStage(error, "encrypt", {
+      ...error?.path ? { path: error.path } : {}
+    });
+  }
+}
+async function putSharedFile(data, options = {}) {
+  const upload = await makeSharedFileUpload(data, options);
+  try {
+    if (typeof options?.uploadSharedMedia !== "function") {
+      throw new Error("shared media upload required");
+    }
+    await options.uploadSharedMedia(upload);
+    return upload.file;
+  } catch (error) {
+    throw setErrorStage(error, "upload", { path: upload.path });
+  }
+}
+async function readChatFile(readChatMedia, file) {
+  let body;
+  try {
+    if (typeof readChatMedia !== "function") {
+      throw new Error("chat media read required");
+    }
+    body = await readChatMedia(file?.p);
+  } catch (error) {
+    error.path = error?.path || file?.p || null;
+    error.stage = error?.stage || "download";
+    throw error;
+  }
+  try {
+    getMediaFileRef(file?.p);
+    const bytes = await openFileForPath(decodeFileKey(file?.k), body, file?.p);
+    return bytes;
+  } catch (error) {
+    error.path = file?.p || null;
+    error.stage = "decrypt";
+    throw error;
+  }
+}
+var init_files = __esm(() => {
+  init_file();
+  init_core();
+  init_filepayload();
+  "use client";
+});
+
+// ../../core/chat/avatar.js
+function chatAvatarFile(value) {
+  const ref = typeof value === "string" ? value.trim() : "";
+  if (!ref.startsWith(CHAT_AVATAR_REF_PREFIX) || ref.length > CHAT_AVATAR_REF_MAX_CHARS)
+    return null;
+  const parts = ref.split(":");
+  const key = parts[2]?.toLowerCase();
+  if (parts.length !== 3 || parts[0] !== "v1" || !FILE_KEY_RE.test(key))
+    return null;
+  let parsed;
+  try {
+    parsed = getChatMediaFileRef(parts[1]);
+  } catch {
+    return null;
+  }
+  return Object.freeze({
+    t: "img",
+    m: "image/webp",
+    p: mediaFilePath(parsed.epochId, parsed.mediaId),
+    k: key
+  });
+}
+function makeChatAvatarRef(file) {
+  let parsed;
+  const path = cleanText(file?.p);
+  const key = cleanText(file?.k).toLowerCase();
+  try {
+    parsed = getChatMediaFileRef(path);
+  } catch {
+    throw new Error("invalid chat avatar");
+  }
+  if (!FILE_KEY_RE.test(key))
+    throw new Error("invalid chat avatar");
+  const ref = `${CHAT_AVATAR_REF_PREFIX}${mediaFilePath(parsed.epochId, parsed.mediaId)}:${key}`;
+  if (ref.length > CHAT_AVATAR_REF_MAX_CHARS)
+    throw new Error("invalid chat avatar");
+  return ref;
+}
+function cleanChatAvatarRef(value) {
+  if (value == null)
+    return null;
+  const file = chatAvatarFile(value);
+  if (!file)
+    throw new Error("invalid chat avatar");
+  return makeChatAvatarRef(file);
+}
+function assertChatAvatarBytes(value) {
+  const bytes = Number(value?.byteLength ?? value?.size);
+  if (!Number.isSafeInteger(bytes) || bytes <= 0 || bytes > CHAT_AVATAR_IMAGE_MAX_BYTES) {
+    throw new Error("invalid chat avatar");
+  }
+  return bytes;
+}
+var CHAT_AVATAR_REF_PREFIX = "v1:", FILE_KEY_RE;
+var init_avatar2 = __esm(() => {
+  init_config();
+  init_filepayload();
+  "use client";
+  FILE_KEY_RE = /^[0-9a-f]{64}$/u;
+});
+
 // ../../core/chat/state.js
 function makeCid() {
   return `${Date.now().toString(36)}${toHex(randomBytes3(3))}`;
@@ -9690,6 +10114,11 @@ function makeChatUnavailableError() {
   error.code = "permission-denied";
   return error;
 }
+function isChatEpochConflict(error) {
+  const code = String(error?.code || "").trim().toLowerCase();
+  const message = String(error?.message || "").trim().toLowerCase();
+  return code === "permission-denied" || code.endsWith("/permission-denied") || code === "aborted" || code.endsWith("/aborted") || code === "failed-precondition" || code.endsWith("/failed-precondition") || message.includes("insufficient permissions") || message === "chat owner epoch changed";
+}
 function makeMessageSaveUnavailableError() {
   const error = new Error("this message can't be saved anymore");
   error.code = "message-unavailable";
@@ -10169,34 +10598,6 @@ var init_chat = __esm(() => {
   MSG_BODY_HEADER_BYTES = 1 + 1 + 1 + BOX_NONCE_BYTES + ED25519_SIGNATURE_BYTES;
 });
 
-// ../../core/chat/avatar.js
-function cleanChatAvatarRef(value) {
-  if (value == null)
-    return null;
-  const ref = cleanText(value);
-  if (!ref || ref.length > CHAT_AVATAR_REF_MAX_CHARS) {
-    throw new Error("invalid chat avatar");
-  }
-  return ref;
-}
-function chatAvatarDataUrl(value) {
-  const ref = typeof value === "string" ? value.trim() : "";
-  if (!ref.startsWith(CHAT_AVATAR_PREFIX) || ref.length > CHAT_AVATAR_REF_MAX_CHARS)
-    return "";
-  const body = ref.slice(CHAT_AVATAR_PREFIX.length);
-  if (!body || body.length % 4 !== 0 || !BASE64_RE.test(body))
-    return "";
-  const padding2 = body.endsWith("==") ? 2 : body.endsWith("=") ? 1 : 0;
-  const bytes = body.length / 4 * 3 - padding2;
-  return bytes > 0 && bytes <= CHAT_AVATAR_IMAGE_MAX_BYTES ? ref : "";
-}
-var CHAT_AVATAR_PREFIX = "data:image/webp;base64,", BASE64_RE;
-var init_avatar2 = __esm(() => {
-  init_config();
-  "use client";
-  BASE64_RE = /^[A-Za-z0-9+/]+={0,2}$/u;
-});
-
 // ../../core/chat/epochs/transition.js
 function cleanTime(value) {
   if (!Number.isSafeInteger(value) || value <= 0) {
@@ -10417,7 +10818,7 @@ function normalizeChatStateSettings(value = {}) {
     throw new Error("chat settings required");
   }
   const title = value.title == null ? null : cleanText(value.title);
-  if (title != null && (!title || title.length > 128)) {
+  if (title != null && (!title || title.length > CHAT_TITLE_MAX_CHARS)) {
     throw new Error("invalid chat title");
   }
   return {
@@ -10729,6 +11130,20 @@ function normalizeCurrentEpoch(value) {
     settings: normalizeChatSettingsProjection(value.settings)
   };
 }
+function normalizeOwnerRetirement(value, current) {
+  if (value == null)
+    return null;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("invalid chat owner retirement");
+  }
+  const kind = cleanText(value.kind);
+  const epochVersion = value.epochVersion;
+  if (!Object.values(CHAT_OWNER_RETIREMENT_KINDS).includes(kind) || !Number.isSafeInteger(epochVersion) || epochVersion < current.manifest.epochVersion) {
+    throw new Error("invalid chat owner retirement");
+  }
+  const proposalId = kind === CHAT_OWNER_RETIREMENT_KINDS.LEAVE ? cleanTransitionMessageId(value.proposalId) : null;
+  return { kind, epochVersion, proposalId };
+}
 function normalizeOwnerEntry(value) {
   if (!value || typeof value !== "object" || Array.isArray(value) || value.v !== CHAT_ENTRY_VERSION || value.protocol !== CHAT_PROTOCOL_VERSION) {
     throw new Error("invalid chat entry");
@@ -10749,7 +11164,8 @@ function normalizeOwnerEntry(value) {
     saved: value.saved || null,
     startMs: Number.isFinite(value.startMs) ? value.startMs : null,
     deliveryRegistered: value.deliveryRegistered === true,
-    notificationTag: cleanText(value.notificationTag) || null
+    notificationTag: cleanText(value.notificationTag) || null,
+    retirement: normalizeOwnerRetirement(value.retirement, current)
   };
 }
 async function sealOwnChatEntry(chatPrivateKey, entryId, entry) {
@@ -10790,7 +11206,8 @@ function makeOwnChatEntry(epoch, fields = {}) {
     saved: fields.saved || null,
     startMs: Number.isFinite(fields.startMs) ? fields.startMs : null,
     deliveryRegistered: fields.deliveryRegistered === true,
-    notificationTag: cleanText(fields.notificationTag) || null
+    notificationTag: cleanText(fields.notificationTag) || null,
+    retirement: fields.retirement || null
   });
 }
 function normalizeOwnerEpochRecord(value) {
@@ -10798,6 +11215,7 @@ function normalizeOwnerEpochRecord(value) {
     throw new Error("invalid owner epoch entry");
   }
   const manifest = normalizeEpochManifest(value.manifest);
+  const leaveProposalId = value.leaveProposalId == null ? null : cleanTransitionMessageId(value.leaveProposalId);
   return {
     v: CHAT_OWNER_EPOCH_ENTRY_VERSION,
     protocol: CHAT_PROTOCOL_VERSION,
@@ -10807,8 +11225,9 @@ function normalizeOwnerEpochRecord(value) {
     manifest,
     epochSecret: cleanChatHex(value.epochSecret, "epoch secret"),
     cutoffMs: Number.isFinite(value.cutoffMs) ? value.cutoffMs : null,
-    successorTransitionCommitment: cleanTransitionCommitment(value.successorTransitionCommitment),
-    successorTransitionMessageId: cleanTransitionMessageId(value.successorTransitionMessageId)
+    successorTransitionCommitment: leaveProposalId ? null : cleanTransitionCommitment(value.successorTransitionCommitment),
+    successorTransitionMessageId: leaveProposalId ? null : cleanTransitionMessageId(value.successorTransitionMessageId),
+    leaveProposalId
   };
 }
 function makeOwnerEpochRecord(manifest, epochSecret, fields = {}) {
@@ -10819,7 +11238,8 @@ function makeOwnerEpochRecord(manifest, epochSecret, fields = {}) {
     epochSecret: secretHex(epochSecret, "epoch secret"),
     cutoffMs: Number.isFinite(fields.cutoffMs) ? fields.cutoffMs : null,
     successorTransitionCommitment: fields.successorTransitionCommitment,
-    successorTransitionMessageId: fields.successorTransitionMessageId
+    successorTransitionMessageId: fields.successorTransitionMessageId,
+    leaveProposalId: fields.leaveProposalId
   });
 }
 async function sealOwnerEpochRecord(chatPrivateKey, entryId, epochEntryId, record) {
@@ -10843,7 +11263,7 @@ async function openOwnerEpochRecord(chatPrivateKey, entryId, epochEntryId, body)
 function ownEpochEntryId(chatPrivateKey, chatId, epochId) {
   return ownerEpochEntryId(chatPrivateKey, chatId, epochId);
 }
-var CHAT_ENTRY_VERSION = 4, CHAT_OWNER_EPOCH_ENTRY_VERSION = 2;
+var CHAT_ENTRY_VERSION = 4, CHAT_OWNER_EPOCH_ENTRY_VERSION = 2, CHAT_OWNER_RETIREMENT_KINDS;
 var init_entry = __esm(() => {
   init_canonical();
   init_core();
@@ -10855,6 +11275,10 @@ var init_entry = __esm(() => {
   init_state2();
   init_settings2();
   "use client";
+  CHAT_OWNER_RETIREMENT_KINDS = Object.freeze({
+    LEAVE: "leave",
+    REMOVED: "removed"
+  });
 });
 
 // ../../core/chat/epochs/bootstrap.js
@@ -10995,6 +11419,32 @@ async function mutateOwnChatEntry(cloud, identity, entryId, current, update) {
   const committed = await cloud.user.chats.mutate(identity.uid, entryId, mutation);
   return committed?.result ?? mutation.result ?? null;
 }
+async function retireOwnChatEntry(cloud, identity, entryId, current, fields = {}) {
+  const expectedEpochVersion = fields.expectedEpochVersion;
+  const retirement = fields.retirement;
+  if (!Number.isSafeInteger(expectedEpochVersion) || expectedEpochVersion < 1 || !retirement?.kind || !Number.isSafeInteger(retirement.epochVersion)) {
+    throw new Error("chat owner retirement required");
+  }
+  return mutateOwnChatEntry(cloud, identity, entryId, current, (latest) => {
+    if (latest?.retirement?.kind === retirement.kind && latest.retirement.epochVersion >= retirement.epochVersion) {
+      return { result: latest };
+    }
+    if (latest?.retirement || latest?.current?.manifest?.epochVersion !== expectedEpochVersion) {
+      throw new Error("chat owner epoch changed");
+    }
+    return {
+      entry: {
+        ...latest,
+        routes: {},
+        deliveryRegistered: false,
+        notificationTag: null,
+        retirement
+      },
+      epochs: fields.epoch ? [fields.epoch] : [],
+      mlsDeletes: fields.mlsStateId ? [fields.mlsStateId] : []
+    };
+  });
+}
 async function openOwnChatMutationEntry(identity, entryId, record) {
   if (!record)
     return null;
@@ -11011,369 +11461,6 @@ var init_owner = __esm(() => {
   "use client";
 });
 
-// ../../core/crypto/file.js
-function createFileKey() {
-  return randomBytes3(32);
-}
-function encodeFileKey(key) {
-  return toHex(toBytes32(key, "file key"));
-}
-function decodeFileKey(key) {
-  return toBytes32(key, "file key");
-}
-function getFileAadForPath(scope) {
-  if (!scope) {
-    throw new Error("file scope required");
-  }
-  return encodeScope(FILE_SCOPE, [scope]);
-}
-function getSubtleCrypto() {
-  const subtle = globalThis.crypto?.subtle;
-  if (!subtle) {
-    throw new Error("WebCrypto AES-GCM unavailable");
-  }
-  return subtle;
-}
-async function importAesKey(key, usages) {
-  return getSubtleCrypto().importKey("raw", toBytes32(key, "file key"), { name: "AES-GCM" }, false, usages);
-}
-async function sealFile(key, bytes, scope) {
-  const fileKey = new Uint8Array(toBytes32(key, "file key"));
-  try {
-    const cryptoKey = await importAesKey(fileKey, ["encrypt"]);
-    const iv = randomBytes3(FILE_IV_BYTES);
-    const ct = await getSubtleCrypto().encrypt({
-      name: "AES-GCM",
-      iv,
-      tagLength: FILE_TAG_BYTES * 8,
-      additionalData: getFileAadForPath(scope)
-    }, cryptoKey, toBytes(bytes, "plaintext"));
-    return packBodyData(iv, new Uint8Array(ct));
-  } finally {
-    cleanBytes(fileKey);
-  }
-}
-async function openFileForPath(key, body, scope) {
-  const fileKey = new Uint8Array(toBytes32(key, "file key"));
-  try {
-    const cryptoKey = await importAesKey(fileKey, ["decrypt"]);
-    const { nonce, ct } = unpackBodyData(body, FILE_IV_BYTES);
-    const pt = await getSubtleCrypto().decrypt({
-      name: "AES-GCM",
-      iv: nonce,
-      tagLength: FILE_TAG_BYTES * 8,
-      additionalData: getFileAadForPath(scope)
-    }, cryptoKey, ct);
-    return new Uint8Array(pt);
-  } finally {
-    cleanBytes(fileKey);
-  }
-}
-var FILE_SCOPE = "file-body", FILE_IV_BYTES = 12, FILE_TAG_BYTES = 16;
-var init_file = __esm(() => {
-  init_core();
-  init_kdf();
-  init_pack();
-  "use client";
-});
-
-// ../../core/chat/filepayload.js
-function cleanMediaEpochId(value) {
-  const epochId = String(value || "").trim();
-  if (!new RegExp(`^${CHAT_ID_PATTERN}$`).test(epochId)) {
-    throw new Error("invalid media epoch id");
-  }
-  return epochId.toLowerCase();
-}
-function cleanMediaId(value) {
-  const mediaId = String(value || "").trim();
-  if (!new RegExp(`^${MEDIA_ID_PATTERN}$`).test(mediaId)) {
-    throw new Error("invalid media id");
-  }
-  return mediaId.toLowerCase();
-}
-function cleanSharedMediaId(value) {
-  const sharedId = String(value || "").trim();
-  if (!new RegExp(`^${SHARED_MEDIA_ID_PATTERN}$`).test(sharedId)) {
-    throw new Error("invalid shared media id");
-  }
-  return sharedId.toLowerCase();
-}
-function makeChatMediaId() {
-  return toHex(randomBytes3(16));
-}
-function mediaFilePath(epochId, mediaId) {
-  const nextEpochId = cleanMediaEpochId(epochId);
-  const nextMediaId = cleanMediaId(mediaId);
-  return `${CHAT_MEDIA_ROOT}/${nextEpochId}/${nextMediaId}`;
-}
-function sharedMediaFilePath(sharedId) {
-  const nextSharedId = cleanSharedMediaId(sharedId);
-  return `${SHARED_MEDIA_ROOT}/${nextSharedId}`;
-}
-function makeSharedMediaId() {
-  return toHex(randomBytes3(16));
-}
-function getMediaFileRef(path) {
-  const value = String(path || "").trim();
-  const chatMatch = value.match(CHAT_MEDIA_FILE_PATTERN);
-  if (chatMatch?.[1] && chatMatch?.[2]) {
-    return {
-      type: "chat",
-      epochId: chatMatch[1].toLowerCase(),
-      mediaId: chatMatch[2].toLowerCase()
-    };
-  }
-  const sharedMatch = value.match(SHARED_MEDIA_FILE_PATTERN);
-  if (sharedMatch?.[1]) {
-    return {
-      type: "shared",
-      sharedId: sharedMatch[1].toLowerCase()
-    };
-  }
-  throw new Error("invalid media file path");
-}
-function getChatMediaFileRef(path) {
-  const ref = getMediaFileRef(path);
-  if (ref?.type !== "chat") {
-    throw new Error("invalid media file path");
-  }
-  return ref;
-}
-function getSharedMediaFileRef(path) {
-  const ref = getMediaFileRef(path);
-  if (ref?.type !== "shared") {
-    throw new Error("invalid shared media file path");
-  }
-  return ref;
-}
-function uploadByteLength(value) {
-  if (Number.isFinite(value?.byteLength)) {
-    return value.byteLength;
-  }
-  if (Number.isFinite(value?.size)) {
-    return value.size;
-  }
-  if (Number.isFinite(value)) {
-    return value;
-  }
-  return null;
-}
-function makeChatUploadTooLargeError(bytes, maxBytes = MAX_CHAT_UPLOAD_BYTES) {
-  const error = new Error("upload too large");
-  error.code = "upload-too-large";
-  error.maxBytes = maxBytes;
-  if (Number.isFinite(bytes)) {
-    error.bytes = bytes;
-  }
-  return error;
-}
-function assertChatUploadByteSize(bytes, maxBytes = MAX_CHAT_UPLOAD_BYTES) {
-  const length = uploadByteLength(bytes);
-  if (!Number.isFinite(length)) {
-    throw new Error("upload bytes required");
-  }
-  if (length <= 0 || length > maxBytes) {
-    throw makeChatUploadTooLargeError(length, maxBytes);
-  }
-  return length;
-}
-async function toUploadBytes(data) {
-  if (typeof Blob !== "undefined" && data instanceof Blob) {
-    if (typeof data.arrayBuffer === "function") {
-      return new Uint8Array(await data.arrayBuffer());
-    }
-    if (typeof FileReader !== "undefined") {
-      return new Promise((resolve, reject) => {
-        const reader = new FileReader;
-        reader.onload = () => resolve(new Uint8Array(reader.result));
-        reader.onerror = () => reject(reader.error || new Error("blob read failed"));
-        reader.readAsArrayBuffer(data);
-      });
-    }
-    if (typeof Response !== "undefined") {
-      return new Uint8Array(await new Response(data).arrayBuffer());
-    }
-  }
-  if (typeof data?.arrayBuffer === "function") {
-    return new Uint8Array(await data.arrayBuffer());
-  }
-  return toBytes(data, "upload bytes");
-}
-async function makeChatFileUploadPayload(epochId, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
-  const nextEpochId = cleanMediaEpochId(epochId);
-  const mediaId = makeChatMediaId();
-  const path = mediaFilePath(nextEpochId, mediaId);
-  const expiresAt = Date.now() + CHAT_MEDIA_TTL_MS2;
-  const key = createFileKey();
-  try {
-    const uploadBytes = await toUploadBytes(data);
-    assertChatUploadByteSize(uploadBytes);
-    const body = await sealFile(key, uploadBytes, path);
-    assertChatUploadByteSize(body);
-    return {
-      epochId: nextEpochId,
-      mediaId,
-      path,
-      body,
-      metadata: {
-        contentType: "application/octet-stream",
-        cacheControl
-      },
-      file: {
-        p: path,
-        k: encodeFileKey(key),
-        x: expiresAt
-      }
-    };
-  } catch (error) {
-    if (error && typeof error === "object") {
-      error.path = error?.path || path;
-      error.cid = error?.cid || cid;
-    }
-    throw error;
-  } finally {
-    cleanBytes(key);
-  }
-}
-async function makeSharedFileUploadPayload(data, { contentType = "application/octet-stream", cacheControl = "private, max-age=0, no-transform" } = {}) {
-  const sharedId = makeSharedMediaId();
-  const path = sharedMediaFilePath(sharedId);
-  const expiresAt = Date.now() + CHAT_MEDIA_TTL_MS2;
-  const key = createFileKey();
-  try {
-    const uploadBytes = await toUploadBytes(data);
-    assertChatUploadByteSize(uploadBytes);
-    const body = await sealFile(key, uploadBytes, path);
-    assertChatUploadByteSize(body);
-    return {
-      sharedId,
-      path,
-      body,
-      metadata: {
-        contentType,
-        cacheControl
-      },
-      file: {
-        p: path,
-        k: encodeFileKey(key),
-        x: expiresAt
-      }
-    };
-  } catch (error) {
-    if (error && typeof error === "object") {
-      error.path = error?.path || path;
-      error.sharedId = error?.sharedId || sharedId;
-    }
-    throw error;
-  } finally {
-    cleanBytes(key);
-  }
-}
-var CHAT_MEDIA_ROOT = "chatEpochs", SHARED_MEDIA_ROOT = "shared", CHAT_MEDIA_TTL_MS2, MAX_CHAT_UPLOAD_BYTES, CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS2, CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS2, CHAT_VIDEO_TRANSCODE_TOTAL_BITRATE_BPS, CHAT_ID_PATTERN = "[0-9a-fA-F]{64}", SHARED_MEDIA_ID_PATTERN = "[0-9a-fA-F]{32}", MEDIA_ID_PATTERN = "[0-9a-fA-F]{32}", CHAT_MEDIA_FILE_PATTERN, SHARED_MEDIA_FILE_PATTERN;
-var init_filepayload = __esm(() => {
-  init_file();
-  init_config();
-  init_core();
-  "use client";
-  CHAT_MEDIA_TTL_MS2 = CHAT_MEDIA_TTL_MS;
-  MAX_CHAT_UPLOAD_BYTES = CHAT_UPLOAD_MAX_BYTES;
-  CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS2 = CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS;
-  CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS2 = CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS;
-  CHAT_VIDEO_TRANSCODE_TOTAL_BITRATE_BPS = CHAT_VIDEO_TRANSCODE_VIDEO_BITRATE_BPS2 + CHAT_VIDEO_TRANSCODE_AUDIO_BITRATE_BPS2;
-  CHAT_MEDIA_FILE_PATTERN = new RegExp(`^${CHAT_MEDIA_ROOT}/(${CHAT_ID_PATTERN})/(${MEDIA_ID_PATTERN})$`);
-  SHARED_MEDIA_FILE_PATTERN = new RegExp(`^${SHARED_MEDIA_ROOT}/(${SHARED_MEDIA_ID_PATTERN})$`);
-});
-
-// ../../core/files.js
-function makeFileId(size = 8) {
-  return toHex(randomBytes3(size));
-}
-function setErrorStage(error, stage, extra = {}) {
-  if (!error || typeof error !== "object") {
-    return error;
-  }
-  error.stage = error?.stage || stage;
-  Object.assign(error, extra);
-  return error;
-}
-async function makeChatFileUpload(epochId, cid, data, { cacheControl = "private, max-age=0, no-transform" } = {}) {
-  try {
-    return await makeChatFileUploadPayload(epochId, cid, data, {
-      cacheControl
-    });
-  } catch (error) {
-    throw setErrorStage(error, "encrypt", {
-      ...error?.path ? { path: error.path } : {},
-      cid
-    });
-  }
-}
-async function putChatFile(epochId, cid, data, options) {
-  const upload = await makeChatFileUpload(epochId, cid, data, options);
-  try {
-    if (typeof options?.uploadChatMedia !== "function") {
-      throw new Error("chat media upload required");
-    }
-    await options.uploadChatMedia(upload);
-    return upload.file;
-  } catch (error) {
-    throw setErrorStage(error, "upload", { path: upload.path, cid });
-  }
-}
-async function makeSharedFileUpload(data, { contentType = "application/octet-stream", cacheControl = "private, max-age=0, no-transform" } = {}) {
-  try {
-    return await makeSharedFileUploadPayload(data, {
-      contentType,
-      cacheControl
-    });
-  } catch (error) {
-    throw setErrorStage(error, "encrypt", {
-      ...error?.path ? { path: error.path } : {}
-    });
-  }
-}
-async function putSharedFile(data, options = {}) {
-  const upload = await makeSharedFileUpload(data, options);
-  try {
-    if (typeof options?.uploadSharedMedia !== "function") {
-      throw new Error("shared media upload required");
-    }
-    await options.uploadSharedMedia(upload);
-    return upload.file;
-  } catch (error) {
-    throw setErrorStage(error, "upload", { path: upload.path });
-  }
-}
-async function readChatFile(readChatMedia, file) {
-  let body;
-  try {
-    if (typeof readChatMedia !== "function") {
-      throw new Error("chat media read required");
-    }
-    body = await readChatMedia(file?.p);
-  } catch (error) {
-    error.path = error?.path || file?.p || null;
-    error.stage = error?.stage || "download";
-    throw error;
-  }
-  try {
-    getMediaFileRef(file?.p);
-    const bytes = await openFileForPath(decodeFileKey(file?.k), body, file?.p);
-    return bytes;
-  } catch (error) {
-    error.path = file?.p || null;
-    error.stage = "decrypt";
-    throw error;
-  }
-}
-var init_files = __esm(() => {
-  init_file();
-  init_core();
-  init_filepayload();
-  "use client";
-});
-
 // ../../core/chat/messages/types.js
 var ATTACHMENT_MSG_TYPES, MAX_TXT_CHARS, REACTION_MSG_TYPE = "rxn", DELETE_MSG_TYPE = "del", SYSTEM_MSG_TYPE = "sys", EPOCH_TRANSITION_MSG_TYPE = "epoch", EPOCH_PROPOSAL_MSG_TYPE = "epoch_proposal", SYSTEM_SETTINGS_KIND = "settings", DEFAULT_REACTION_EMOJI = "❤️", MAX_REACTIONS, HOLD_VISIBLE_KEY = "__holdVisible", SOURCE_GONE_VISIBLE_KEY = "__sourceGoneVisible";
 var init_types = __esm(() => {
@@ -12080,48 +12167,6 @@ function cleanFrontier(value) {
     throw new Error("chat receipt checkpoint frontier time required");
   return Object.freeze({ id, at: value.at, seenAt: value.seenAt });
 }
-function maskBytes(memberCount2) {
-  return Math.ceil(memberCount2 / 8);
-}
-function cleanMask(value, memberCount2, label) {
-  const mask = cleanText(value).toLowerCase();
-  const size = maskBytes(memberCount2);
-  if (!new RegExp(`^[0-9a-f]{${size * 2}}$`, "u").test(mask)) {
-    throw new Error(`${label} invalid`);
-  }
-  const unused = size * 8 - memberCount2;
-  if (unused > 0 && Number.parseInt(mask.slice(-2), 16) & (1 << unused) - 1 << 8 - unused) {
-    throw new Error(`${label} overflow`);
-  }
-  return mask;
-}
-function makeMask(indices, memberCount2) {
-  const bytes = new Uint8Array(maskBytes(memberCount2));
-  for (const index of indices)
-    bytes[Math.floor(index / 8)] |= 1 << index % 8;
-  return [...bytes].map((value) => value.toString(16).padStart(2, "0")).join("");
-}
-function maskHas(mask, index) {
-  const offset = Math.floor(index / 8) * 2;
-  return (Number.parseInt(mask.slice(offset, offset + 2), 16) & 1 << index % 8) !== 0;
-}
-function maskCount(mask, memberCount2) {
-  let count = 0;
-  for (let index = 0;index < memberCount2; index += 1) {
-    if (maskHas(mask, index))
-      count += 1;
-  }
-  return count;
-}
-function frontierWithSeenAt(frontier, states) {
-  if (!frontier)
-    return null;
-  return {
-    id: frontier.id,
-    at: frontier.at,
-    seenAt: Math.max(frontier.seenAt, ...states.map((state) => Number(state?.readFrontier?.seenAt) || 0))
-  };
-}
 function normalizeChatReceiptProjection(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("chat receipt checkpoint projection required");
@@ -12130,41 +12175,13 @@ function normalizeChatReceiptProjection(value) {
   if (!Array.isArray(value.revisions) || value.revisions.length !== memberCount2) {
     throw new Error("chat receipt checkpoint revisions invalid");
   }
-  const lowFrontier = cleanFrontier(value.lowFrontier);
-  const nextLowFrontier = cleanFrontier(value.nextLowFrontier);
-  const highFrontier = cleanFrontier(value.highFrontier);
-  const nextHighFrontier = cleanFrontier(value.nextHighFrontier);
-  const lowMask = cleanMask(value.lowMask, memberCount2, "chat receipt checkpoint low mask");
-  const highMask = cleanMask(value.highMask, memberCount2, "chat receipt checkpoint high mask");
-  const nextHighMask = cleanMask(value.nextHighMask, memberCount2, "chat receipt checkpoint next high mask");
-  if (!highFrontier && maskCount(highMask, memberCount2) !== 0) {
-    throw new Error("chat receipt checkpoint high frontier missing");
-  }
-  if (highFrontier && maskCount(highMask, memberCount2) === 0) {
-    throw new Error("chat receipt checkpoint high readers missing");
-  }
-  if (!nextHighFrontier && maskCount(nextHighMask, memberCount2) !== 0) {
-    throw new Error("chat receipt checkpoint next high frontier missing");
-  }
-  if (nextHighFrontier && maskCount(nextHighMask, memberCount2) === 0) {
-    throw new Error("chat receipt checkpoint next high readers missing");
-  }
-  if (lowFrontier && compareReadFrontiers(lowFrontier, highFrontier) > 0) {
-    throw new Error("chat receipt checkpoint frontier order invalid");
-  }
-  if (nextLowFrontier && compareReadFrontiers(nextLowFrontier, highFrontier) > 0) {
-    throw new Error("chat receipt checkpoint next frontier order invalid");
+  if (!Array.isArray(value.frontiers) || value.frontiers.length !== memberCount2) {
+    throw new Error("chat receipt checkpoint frontiers invalid");
   }
   return Object.freeze({
     memberCount: memberCount2,
     revisions: Object.freeze(value.revisions.map(cleanRevision3)),
-    lowFrontier,
-    lowMask,
-    nextLowFrontier,
-    highFrontier,
-    highMask,
-    nextHighFrontier,
-    nextHighMask
+    frontiers: Object.freeze(value.frontiers.map(cleanFrontier))
   });
 }
 function buildChatReceiptProjection(manifest, states) {
@@ -12172,36 +12189,66 @@ function buildChatReceiptProjection(manifest, states) {
   const memberCount2 = cleanCount(members.length);
   const values = members.map((member) => states?.get?.(member.chatPK) || null);
   const revisions = values.map((state) => Math.max(0, Number(state?.revision) || 0));
-  const missing = [];
-  const present = [];
-  values.forEach((state, index) => {
-    if (state?.readFrontier)
-      present.push({ index, state, frontier: state.readFrontier });
-    else
-      missing.push(index);
-  });
-  present.sort((left, right) => compareReadFrontiers(left.frontier, right.frontier));
-  const minimum = present[0]?.frontier || null;
-  const maximum = present.at(-1)?.frontier || null;
-  const lowIndices = missing.length ? missing : present.filter((item) => compareReadFrontiers(item.frontier, minimum) === 0).map((item) => item.index);
-  const nextLowItems = missing.length ? present : present.filter((item) => compareReadFrontiers(item.frontier, minimum) > 0);
-  const nextLow = nextLowItems[0]?.frontier || null;
-  const highItems = maximum ? present.filter((item) => compareReadFrontiers(item.frontier, maximum) === 0) : [];
-  const belowHigh = maximum ? present.filter((item) => compareReadFrontiers(item.frontier, maximum) < 0) : [];
-  const nextHigh = belowHigh.at(-1)?.frontier || null;
-  const nextHighItems = nextHigh ? belowHigh.filter((item) => compareReadFrontiers(item.frontier, nextHigh) === 0) : [];
   return normalizeChatReceiptProjection({
     memberCount: memberCount2,
     revisions,
-    lowFrontier: missing.length ? null : frontierWithSeenAt(minimum, values.filter(Boolean)),
-    lowMask: makeMask(lowIndices, memberCount2),
-    nextLowFrontier: frontierWithSeenAt(nextLow, nextLowItems.map((item) => item.state)),
-    highFrontier: frontierWithSeenAt(maximum, highItems.map((item) => item.state)),
-    highMask: makeMask(highItems.map((item) => item.index), memberCount2),
-    nextHighFrontier: frontierWithSeenAt(nextHigh, nextHighItems.map((item) => item.state)),
-    nextHighMask: makeMask(nextHighItems.map((item) => item.index), memberCount2)
+    frontiers: values.map((state) => state?.readFrontier || null)
   });
 }
+function mergeChatReceiptProjections(current, incoming) {
+  if (!current)
+    return normalizeChatReceiptProjection(incoming);
+  if (!incoming)
+    return normalizeChatReceiptProjection(current);
+  const left = normalizeChatReceiptProjection(current);
+  const right = normalizeChatReceiptProjection(incoming);
+  if (left.memberCount !== right.memberCount) {
+    throw new Error("chat receipt checkpoint member count mismatch");
+  }
+  return normalizeChatReceiptProjection({
+    memberCount: left.memberCount,
+    revisions: left.revisions.map((revision, index) => Math.max(revision, right.revisions[index])),
+    frontiers: left.frontiers.map((frontier, index) => {
+      const other = right.frontiers[index];
+      const comparison = compareReadFrontiers(frontier, other);
+      if (comparison > 0)
+        return frontier;
+      if (comparison < 0)
+        return other;
+      if (!frontier)
+        return null;
+      return {
+        ...frontier,
+        seenAt: Math.max(frontier.seenAt, other.seenAt)
+      };
+    })
+  });
+}
+function mergeChatReceiptCheckpointsByEpoch(current, incoming) {
+  if (!(incoming instanceof Map) || !incoming.size) {
+    return current instanceof Map ? current : new Map;
+  }
+  if (!(current instanceof Map) || !current.size)
+    return new Map(incoming);
+  const merged = new Map(current instanceof Map ? current : []);
+  let changed = false;
+  for (const [epochId, value] of incoming instanceof Map ? incoming : []) {
+    const existing = merged.get(epochId);
+    if (existing === value)
+      continue;
+    const exact = isChatReceiptCheckpoint(existing) && isChatReceiptCheckpoint(value) && existing.epochId === value.epochId && existing.memberChatPKs.length === value.memberChatPKs.length && existing.memberChatPKs.every((chatPK, index) => chatPK === value.memberChatPKs[index]);
+    const next = exact ? Object.freeze({
+      ...value,
+      publishedAt: Math.max(Number(existing.publishedAt) || 0, Number(value.publishedAt) || 0) || null,
+      projection: mergeChatReceiptProjections(existing.projection, value.projection)
+    }) : value;
+    if (exact && sameChatReceiptCheckpoint(existing, next) && existing.publishedAt === next.publishedAt)
+      continue;
+    merged.set(epochId, next);
+    changed = true;
+  }
+  return changed ? merged : current;
+}
 function projectChatReceiptCheckpoint(manifest, value) {
   const projection = normalizeChatReceiptProjection(value?.projection || value);
   if (projection.memberCount !== manifest?.members?.length) {
@@ -12234,13 +12281,14 @@ function chatReceiptCheckpointCoversState(checkpoint, manifest, state) {
 function chatReceiptAllSeenFrontier(checkpoint, authorChatPK) {
   if (!isChatReceiptCheckpoint(checkpoint))
     return null;
-  const { lowFrontier, lowMask, nextLowFrontier, memberCount: memberCount2 } = checkpoint.projection;
-  const authorIndex = checkpoint.memberChatPKs?.indexOf?.(authorChatPK) ?? -1;
-  const lowCount = maskCount(lowMask, memberCount2);
-  if (authorIndex >= 0 && lowCount === 1 && maskHas(lowMask, authorIndex)) {
-    return nextLowFrontier;
-  }
-  return lowFrontier;
+  const readers = checkpoint.projection.frontiers.filter((_frontier, index) => checkpoint.memberChatPKs[index] !== authorChatPK);
+  if (!readers.length || readers.some((frontier) => !frontier))
+    return null;
+  const minimum = readers.reduce((current, frontier) => !current || compareReadFrontiers(frontier, current) < 0 ? frontier : current, null);
+  return Object.freeze({
+    ...minimum,
+    seenAt: Math.max(...readers.map((frontier) => frontier.seenAt))
+  });
 }
 function chatReceiptProjectionFingerprint(value) {
   return JSON.stringify(normalizeChatReceiptProjection(value));
@@ -12321,7 +12369,7 @@ function cleanChatSettingsEventTitle(value) {
   if (value == null)
     return null;
   const title = cleanText(value);
-  if (!title || title.length > 128)
+  if (!title || title.length > CHAT_TITLE_MAX_CHARS)
     throw new Error("invalid chat settings event title");
   return title;
 }
@@ -12336,10 +12384,7 @@ function makeChatSettingsMsg(revision, digest, changes = [], values = {}) {
   const titleChanged = cleanChanges.includes("title");
   const avatarChanged = cleanChanges.includes("avatarRef");
   const title = titleChanged ? cleanChatSettingsEventTitle(values?.title) : undefined;
-  const avatarRef = avatarChanged ? values?.avatarRef == null ? null : chatAvatarDataUrl(values.avatarRef) : undefined;
-  if (avatarChanged && values?.avatarRef != null && !avatarRef) {
-    throw new Error("invalid chat settings event avatar");
-  }
+  const avatarRef = avatarChanged ? values?.avatarRef == null ? null : cleanChatAvatarRef(values.avatarRef) : undefined;
   return {
     t: SYSTEM_MSG_TYPE,
     sys: SYSTEM_SETTINGS_KIND,
@@ -12362,7 +12407,7 @@ function isChatSettingsMsg(msg) {
       return false;
     }
   }
-  return !changes.includes("avatarRef") || msg?.avatarRef == null || !!chatAvatarDataUrl(msg.avatarRef);
+  return !changes.includes("avatarRef") || msg?.avatarRef == null || !!chatAvatarFile(msg.avatarRef);
 }
 function isPendingChatSettingsMsg(msg) {
   return msg?.t === SYSTEM_MSG_TYPE && msg?.sys === SYSTEM_SETTINGS_KIND && msg?.pending === true && String(msg?.id || "").startsWith("local:") && chatSettingsEventChanges(msg).length === 1 && chatSettingsEventChanges(msg)[0] === "retention";
@@ -12370,7 +12415,7 @@ function isPendingChatSettingsMsg(msg) {
 function getChatSettingsEventAvatar(msg) {
   if (!isChatSettingsMsg(msg) || !chatSettingsEventChanges(msg).includes("avatarRef"))
     return "";
-  return chatAvatarDataUrl(msg?.avatarRef);
+  return chatAvatarFile(msg?.avatarRef) ? msg.avatarRef : "";
 }
 function isSystemMsg(msg) {
   return !!getSystemMsgText(msg) && (msg?.t === SYSTEM_MSG_TYPE || isMembershipEventMsg(msg));
@@ -12602,7 +12647,7 @@ function getLatestLocalReadTarget(messages, chatPK) {
 function getLatestReadStateTarget(messages) {
   for (let i = (messages?.length || 0) - 1;i >= 0; i -= 1) {
     const message = messages[i];
-    if (isServerConfirmedMsg(message) && canShowMsg(message) && !isSystemMsg(message))
+    if (isServerConfirmedMsg(message) && !isSystemMsg(message) && (canShowMsg(message) || isReactionMsg(message)))
       return message;
   }
   return null;
@@ -12735,6 +12780,7 @@ var init_control = __esm(() => {
   init_messagekeys();
   init_ttl();
   init_actions();
+  init_config();
   init_avatar2();
   init_files2();
   init_text();
@@ -13241,13 +13287,12 @@ function withChatPreviewExpired(preview, expiredAt) {
     sourceTs: getChatPreviewSourceTs(preview)
   }));
 }
-function chatPreviewWantsAttention(preview, chatPK) {
+function chatPreviewCountsAsUnseen(preview, chatPK) {
   if (!preview || fromSelf(preview, chatPK)) {
     return false;
   }
   if (isReactionMsg(preview)) {
-    const targetFrom = cleanText(preview?.targetFrom);
-    return !!cleanText(preview?.emoji) && (!targetFrom || targetFrom === chatPK);
+    return !!cleanText(preview?.emoji);
   }
   return canRenderPreviewContent(preview);
 }
@@ -14752,10 +14797,6 @@ async function prepareOwnerChatMlsSnapshot(identity, entryId, epochState, snapsh
 function ownerChatMlsSnapshotId(identity, entryId, epochState) {
   return stateAddress(identity, entryId, epochState).stateId;
 }
-async function discardOwnerChatMlsSnapshot(cloud, identity, entryId, epochState) {
-  const address = stateAddress(identity, entryId, epochState);
-  await cloud.user.chats.mls.delete(identity.uid, entryId, address.stateId).catch(() => false);
-}
 var init_owner2 = __esm(() => {
   init_state3();
   "use client";
@@ -15926,7 +15967,7 @@ function getPeersFromChats(chats) {
 }
 function isChatUnseenForUser(chatData, userChatPK) {
   const last = chatData?.preview;
-  if (!last?.ts || !chatPreviewWantsAttention(last, userChatPK))
+  if (!last?.ts || !chatPreviewCountsAsUnseen(last, userChatPK))
     return false;
   const readMs = timestampMs(chatData?.readMs, null);
   const lastMs = timestampMs(last.ts, null);
@@ -16561,7 +16602,45 @@ function reviveMarker(marker) {
 function serializeKeys(keys) {
   return [...keySet(keys)].filter(Boolean).sort();
 }
-function serializeBatch(batch, { expiredKeys, deletedKeys } = {}) {
+function cleanReceiptCheckpoint(value) {
+  if (!isChatReceiptCheckpoint(value))
+    return null;
+  const epochId = cleanText(value.epochId);
+  const memberChatPKs = (value.memberChatPKs || []).map(cleanText).filter(Boolean);
+  if (!epochId || memberChatPKs.length !== value.memberChatPKs?.length)
+    return null;
+  try {
+    return projectChatReceiptCheckpoint({
+      epochId,
+      members: memberChatPKs.map((chatPK) => ({ chatPK }))
+    }, value);
+  } catch {
+    return null;
+  }
+}
+function serializeReceiptCheckpoints(statesByEpoch, epochIds) {
+  const allowed = new Set(epochIds || []);
+  const checkpoints = [];
+  for (const [epochId, value] of statesByEpoch instanceof Map ? statesByEpoch : []) {
+    if (allowed.size && !allowed.has(epochId))
+      continue;
+    const checkpoint = cleanReceiptCheckpoint(value);
+    if (checkpoint)
+      checkpoints.push(checkpoint);
+  }
+  return checkpoints.sort((left, right) => left.epochId.localeCompare(right.epochId));
+}
+function reviveReceiptCheckpoints(values) {
+  return new Map((Array.isArray(values) ? values : []).map((value) => cleanReceiptCheckpoint(value)).filter(Boolean).map((checkpoint) => [checkpoint.epochId, checkpoint]));
+}
+function receiptEpochIds(messages, fallbackEpochId = "") {
+  const ids = new Set((messages || []).map((message) => cleanText(message?.epochId)).filter(Boolean));
+  const fallback = cleanText(fallbackEpochId);
+  if (fallback)
+    ids.add(fallback);
+  return ids;
+}
+function serializeBatch(batch, { expiredKeys, deletedKeys, epochIds } = {}) {
   if (!batch && !expiredKeys?.size && !deletedKeys?.size) {
     return null;
   }
@@ -16571,14 +16650,16 @@ function serializeBatch(batch, { expiredKeys, deletedKeys } = {}) {
     ...Number.isSafeInteger(batch?.epochVersion) ? { epochVersion: batch.epochVersion } : {},
     ...Number.isFinite(batch?.firstMs) ? { firstMs: batch.firstMs } : {},
     ...Number.isFinite(batch?.lastMs) ? { lastMs: batch.lastMs } : {},
+    receiptCheckpoints: serializeReceiptCheckpoints(batch?.memberStatesByEpoch, epochIds),
     expiredKeys: serializeKeys(expiredKeys || batch?.expiredKeys),
     deletedKeys: serializeKeys(deletedKeys || batch?.deletedKeys)
   };
 }
-function batchFromLive(latestMessages, expiredKeys, deletedKeys, fallback) {
+function batchFromLive(latestMessages, expiredKeys, deletedKeys, fallback, receiptMessages = latestMessages) {
   const source = latestMessages || [];
+  const epochIds = receiptEpochIds(receiptMessages, fallback?.epochId);
   if (!source.length) {
-    return serializeBatch(fallback, { expiredKeys, deletedKeys });
+    return serializeBatch(fallback, { expiredKeys, deletedKeys, epochIds });
   }
   const firstMs = getMessageOrderMs(source[0]);
   const lastMs = getMessageOrderMs(source[source.length - 1]);
@@ -16586,8 +16667,9 @@ function batchFromLive(latestMessages, expiredKeys, deletedKeys, fallback) {
     firstMs,
     lastMs,
     epochId: fallback?.epochId,
-    epochVersion: fallback?.epochVersion
-  } : fallback, { expiredKeys, deletedKeys });
+    epochVersion: fallback?.epochVersion,
+    memberStatesByEpoch: fallback?.memberStatesByEpoch
+  } : fallback, { expiredKeys, deletedKeys, epochIds });
 }
 function reviveBatch(batch, expiredKeys, deletedKeys) {
   const hasRange = Number.isFinite(batch?.firstMs) && Number.isFinite(batch?.lastMs);
@@ -16599,6 +16681,7 @@ function reviveBatch(batch, expiredKeys, deletedKeys) {
     ...cleanText(batch?.epochId) ? { epochId: cleanText(batch.epochId) } : {},
     ...Number.isSafeInteger(batch?.epochVersion) ? { epochVersion: batch.epochVersion } : {},
     ...hasRange ? { firstMs: batch.firstMs, lastMs: batch.lastMs } : {},
+    memberStatesByEpoch: reviveReceiptCheckpoints(batch?.receiptCheckpoints),
     expiredKeys,
     deletedKeys
   };
@@ -16615,10 +16698,20 @@ function mergeBatches(left, right) {
     ...Number.isSafeInteger(right?.epochVersion ?? left?.epochVersion) ? { epochVersion: right?.epochVersion ?? left?.epochVersion } : {},
     ...firstValues.length ? { firstMs: Math.min(...firstValues) } : {},
     ...lastValues.length ? { lastMs: Math.max(...lastValues) } : {},
+    memberStatesByEpoch: mergeChatReceiptCheckpointsByEpoch(left?.memberStatesByEpoch, right?.memberStatesByEpoch),
     expiredKeys: keySet([...left?.expiredKeys || [], ...right?.expiredKeys || []]),
     deletedKeys: keySet([...left?.deletedKeys || [], ...right?.deletedKeys || []])
   };
 }
+function cachedReceiptCheckpointSignature(statesByEpoch) {
+  const values = [];
+  for (const [epochId, value] of statesByEpoch instanceof Map ? statesByEpoch : []) {
+    const checkpoint = cleanReceiptCheckpoint(value);
+    if (checkpoint)
+      values.push(`${epochId}:${chatReceiptProjectionFingerprint(checkpoint.projection)}`);
+  }
+  return values.sort().join("|");
+}
 function olderMarker(left, right) {
   if (!left)
     return right || null;
@@ -17021,7 +17114,7 @@ function writeCachedMessageState(cache, { stateVersion = null, chatId, selfChatP
       historyStartReached: nextHistoryStartReached === true,
       olderThan: serializeMarker(storedOlderThan),
       olderLoaded: nextOlderLoaded === true || compacted.historyMessages.length > 0,
-      latestServerPage: batchFromLive(compacted.latestMessages, expiredKeys, deletedKeys, nextServerBatch),
+      latestServerPage: batchFromLive(compacted.latestMessages, expiredKeys, deletedKeys, nextServerBatch, compacted.all),
       deletedKeys: serializeKeys(deletedKeys),
       expiredKeys: serializeKeys(expiredKeys),
       historyMessages: compacted.historyMessages,
@@ -17050,6 +17143,7 @@ var init_messages2 = __esm(() => {
   init_state();
   init_messagekeys();
   init_compact();
+  init_receipt();
   init_filename();
   init_time();
   init_core();
@@ -18273,11 +18367,13 @@ function createChatDelete({
   listActionsRef,
   closeMessageBatchRef,
   mutationGate,
+  reconcileEpoch,
   diag
 }) {
   const pendingDeleteIdsRef = { current: new Set };
   const locallyDeletedChatIdsRef = { current: new Set };
   const deletedChatIdsRef = { current: new Set };
+  const removedChatVersionsRef = { current: new Map };
   const keepSelectedDeletedChatIdsRef = { current: new Set };
   const isChatPendingDelete = (chatId) => !!chatId && pendingDeleteIdsRef.current.has(chatId);
   const clearDeletedChatState = (chatIds) => {
@@ -18387,20 +18483,46 @@ function createChatDelete({
     listActionsRef.current?.commitServerChats?.(nextServerChats, { warm: false });
     setSelectedChat((current) => current === chatId ? null : current);
   };
-  const dropRemovedChat = (chatId) => {
-    if (!chatId)
+  const dropRemovedChat = (chatId, epochVersion) => {
+    if (!chatId || !Number.isSafeInteger(epochVersion) || epochVersion < 1)
       return false;
-    deletedChatIdsRef.current.add(chatId);
-    locallyDeletedChatIdsRef.current.add(chatId);
+    const previousVersion = removedChatVersionsRef.current.get(chatId) || 0;
+    removedChatVersionsRef.current.set(chatId, Math.max(previousVersion, epochVersion));
     dropChat(chatId);
     return true;
   };
+  const commitRemovedRetirement = (chatId, epochVersion) => {
+    if (!chatId || !Number.isSafeInteger(epochVersion) || epochVersion < 1)
+      return false;
+    const previousVersion = removedChatVersionsRef.current.get(chatId) || 0;
+    removedChatVersionsRef.current.set(chatId, Math.max(previousVersion, epochVersion));
+    pendingDeleteIdsRef.current.delete(chatId);
+    locallyDeletedChatIdsRef.current.delete(chatId);
+    deletedChatIdsRef.current.delete(chatId);
+    keepSelectedDeletedChatIdsRef.current.delete(chatId);
+    confirmDeletedChats([chatId]);
+    return true;
+  };
+  const restoreRemovedChat = (chat) => {
+    const chatId = chat?.id;
+    const removedAtVersion = removedChatVersionsRef.current.get(chatId);
+    if (!chatId || removedAtVersion == null)
+      return false;
+    if (!Number.isSafeInteger(chat.epochVersion) || chat.epochVersion <= removedAtVersion || !Array.isArray(chat.memberChatPKs) || !chat.memberChatPKs.includes(chatPK))
+      return false;
+    removedChatVersionsRef.current.delete(chatId);
+    return true;
+  };
   const dropUnavailableChat = (chatId) => {
     if (!chatId)
       return Promise.resolve(false);
     return (async () => {
       const releaseMutation = await mutationGate?.acquireExclusive(chatId) || (() => {});
       try {
+        if (removedChatVersionsRef.current.has(chatId)) {
+          dropChat(chatId);
+          return true;
+        }
         const chat = lastServerChatsRef.current.find((item) => item?.id === chatId);
         if (chat?.deliveryRegistered && chat?.epochVersion && chatPK && chat?.epochState?.stateCapability) {
           await cloud.delivery.revoke(deriveChatDeliveryCapability(chat.epochState.stateCapability, {
@@ -18477,39 +18599,74 @@ function createChatDelete({
     }, target.members, target.expectedEpochId);
     return result.deliveredCount;
   };
+  const deleteCurrentChat = async (input, options = {}) => {
+    const chatId = cleanText(typeof input === "string" ? input : input?.chatId || input?.id);
+    const attemptedEpochs = new Set;
+    while (chatId) {
+      const target = getDeleteTargets(input)[0];
+      if (!target)
+        return null;
+      const peerChatPK = cleanText(typeof input === "object" ? input?.peerChatPK : "") || cleanText(lastServerChatsRef.current.find((item) => item?.id === chatId)?.peerChatPK);
+      const releaseMutation = await mutationGate?.acquireExclusive([chatId, peerChatPK].filter(Boolean)) || (() => {});
+      let released = false;
+      const release = () => {
+        if (released)
+          return;
+        released = true;
+        releaseMutation();
+      };
+      try {
+        const deletion = await cloud.chat.delete(target.chatId, {
+          entryId: target.entryId,
+          expectedEpochId: target.expectedEpochId,
+          stateCapability: target.stateCapability,
+          cleanup: options.cleanup !== false
+        });
+        if (deletion?.newlyDeleted !== false)
+          await wakeDeletedChat(target);
+        return target;
+      } catch (error) {
+        release();
+        const attemptKey = `${target.epochVersion || 0}:${target.expectedEpochId || ""}`;
+        if (!attemptKey || attemptedEpochs.has(attemptKey) || !isChatEpochConflict(error) || typeof reconcileEpoch !== "function")
+          throw error;
+        attemptedEpochs.add(attemptKey);
+        const reconciled = await reconcileEpoch(chatId);
+        const current = lastServerChatsRef.current.find((item) => item?.id === chatId) || null;
+        if (reconciled?.removed || !current)
+          return null;
+        if (!Number.isSafeInteger(current.epochVersion) || current.epochVersion <= target.epochVersion) {
+          throw error;
+        }
+      } finally {
+        release();
+      }
+    }
+    return null;
+  };
   const deleteChat = async (chat, options = {}) => {
-    const targets = getDeleteTargets(chat);
+    const inputs = Array.isArray(chat) ? chat : [chat];
+    const targets = getDeleteTargets(inputs);
     if (!targets.length)
       return false;
     const chatIds = targets.map((target) => target.chatId);
-    const peerChatPKs = chatIds.map((chatId) => {
-      const input = (Array.isArray(chat) ? chat : [chat]).find((item) => cleanText(typeof item === "string" ? item : item?.chatId || item?.id) === chatId);
-      return cleanText(typeof input === "object" ? input?.peerChatPK : "") || cleanText(lastServerChatsRef.current.find((item) => item?.id === chatId)?.peerChatPK);
-    }).filter(Boolean);
-    const releaseMutation = await mutationGate?.acquireExclusive([...chatIds, ...peerChatPKs]) || (() => {});
+    const deletedTargets = [];
+    hideDeletingChats(chatIds, options);
     try {
-      hideDeletingChats(chatIds, options);
-      try {
-        for (const target of targets) {
-          await cloud.chat.delete(target.chatId, {
-            entryId: target.entryId,
-            expectedEpochId: target.expectedEpochId,
-            stateCapability: target.stateCapability,
-            cleanup: options.cleanup !== false
-          });
-          await wakeDeletedChat(target);
-        }
-        await revokeTargetDeliveries(targets);
-        await options.onDeliveryRevoked?.();
-        confirmDeletedChats(chatIds);
-      } catch (error) {
-        restoreDeletedChats(chatIds);
-        throw error;
-      }
-      return Array.isArray(chat) ? targets.length : true;
-    } finally {
-      releaseMutation();
+      for (const target of targets) {
+        const input = inputs.find((item) => cleanText(typeof item === "string" ? item : item?.chatId || item?.id) === target.chatId) || target.chatId;
+        const deleted = await deleteCurrentChat(input, options);
+        if (deleted)
+          deletedTargets.push(deleted);
+      }
+      await revokeTargetDeliveries(deletedTargets);
+      await options.onDeliveryRevoked?.();
+      confirmDeletedChats(chatIds);
+    } catch (error) {
+      restoreDeletedChats(chatIds);
+      throw error;
     }
+    return Array.isArray(chat) ? targets.length : true;
   };
   const wasChatDeletedLocally = (chatId) => !!chatId && locallyDeletedChatIdsRef.current.has(chatId);
   const ackDeletedChat = (chatId) => {
@@ -18520,21 +18677,25 @@ function createChatDelete({
     pendingDeleteIdsRef.current = new Set;
     locallyDeletedChatIdsRef.current = new Set;
     deletedChatIdsRef.current = new Set;
+    removedChatVersionsRef.current = new Map;
     keepSelectedDeletedChatIdsRef.current = new Set;
   };
   return {
     pendingDeleteIdsRef,
     deletedChatIdsRef,
+    removedChatVersionsRef,
     keepSelectedDeletedChatIdsRef,
     resetDeleteState,
     clearDeletedChatState,
     beginRetirement,
     rollbackRetirement,
     commitRetirement,
+    commitRemovedRetirement,
     restoreDeletedChat,
     deleteChat,
     dropChat,
     dropRemovedChat,
+    restoreRemovedChat,
     dropUnavailableChat,
     wasChatDeletedLocally,
     ackDeletedChat,
@@ -19621,6 +19782,9 @@ var init_chatlive = __esm(() => {
 });
 
 // ../../core/chat/live.js
+function makeChatCompositionId() {
+  return toHex(randomBytes3(16));
+}
 function chatMessageCompositionId(message) {
   const value = String(message?.compositionId || "").trim().toLowerCase();
   return CHAT_COMPOSITION_ID_RE.test(value) ? value : "";
@@ -19804,10 +19968,16 @@ function createChatLive({
     onActivity?.(entry.chatId, EMPTY_ACTIVITY);
   };
   const enterChatActivity = async (chatId) => {
-    if (!enabled || !chatId || rooms.has(chatId))
+    if (!enabled || !chatId)
       return false;
+    const current = rooms.get(chatId);
+    if (current && !current.closed) {
+      current.retainers += 1;
+      return true;
+    }
     const entry = {
       chatId,
+      retainers: 1,
       epochId: "",
       material: null,
       connection: null,
@@ -19883,6 +20053,9 @@ function createChatLive({
     const entry = rooms.get(chatId);
     if (!entry)
       return false;
+    entry.retainers -= 1;
+    if (entry.retainers > 0)
+      return true;
     rooms.delete(chatId);
     destroy(entry);
     return true;
@@ -19930,13 +20103,26 @@ function createChatLive({
     publish(entry);
     return scheduleReadSnapshot(entry);
   };
+  const flushChatReadFrontier = async (chatId) => {
+    const entry = rooms.get(chatId);
+    if (!entry || entry.closed || !entry.connected || !entry.readFrontier)
+      return false;
+    if (!sendSnapshot(entry))
+      return false;
+    const pending = entry.sendChain;
+    await pending;
+    return !entry.closed;
+  };
   const leaveAllChatActivity = () => {
-    for (const chatId of [...rooms.keys()])
-      leaveChatActivity(chatId);
+    for (const [chatId, entry] of [...rooms]) {
+      rooms.delete(chatId);
+      destroy(entry);
+    }
   };
   return Object.freeze({
     close: leaveAllChatActivity,
     enterChatActivity,
+    flushChatReadFrontier,
     leaveChatActivity,
     leaveAllChatActivity,
     markChatReadFrontier,
@@ -20040,7 +20226,73 @@ function withoutChatIdentity(options = {}) {
 }
 function refreshQueuedSendOptions(sendOptionsForPeer, peerChatPK, sendOptionOverrides = null) {
   const chatId = cleanText(sendOptionOverrides?.chatId);
-  return mergeSendOptions(withoutChatIdentity(sendOptionOverrides), sendOptionsForPeer(peerChatPK, chatId));
+  const current = sendOptionsForPeer(peerChatPK, chatId);
+  if (chatId) {
+    return {
+      ...withoutChatIdentity(sendOptionOverrides),
+      ...current
+    };
+  }
+  return mergeSendOptions(withoutChatIdentity(sendOptionOverrides), current);
+}
+function currentEpoch(options) {
+  const manifest = options?.epochState?.manifest || options?.ownEntry?.current?.manifest || null;
+  const epochId = cleanText(manifest?.epochId);
+  const epochVersion = Number(manifest?.epochVersion);
+  return epochId && Number.isInteger(epochVersion) && epochVersion > 0 ? { epochId, epochVersion } : null;
+}
+async function runCurrentEpochWrite({
+  chatId,
+  mutationGate,
+  readOptions,
+  reconcileEpoch,
+  write,
+  onCommitted,
+  onEpochAdvance
+}) {
+  const attemptedEpochs = new Set;
+  while (true) {
+    const releaseMutation = await mutationGate?.acquireShared(chatId) || (() => {});
+    let released = false;
+    let committed = false;
+    const release = () => {
+      if (released)
+        return;
+      released = true;
+      releaseMutation();
+    };
+    let options;
+    let epoch;
+    try {
+      options = readOptions();
+      epoch = currentEpoch(options);
+      return await write(options, (...args) => {
+        committed = true;
+        release();
+        onCommitted?.(...args);
+      });
+    } catch (error) {
+      release();
+      const attemptKey = epoch ? `${epoch.epochVersion}:${epoch.epochId}` : "";
+      if (committed || options?.chatExists !== true || !attemptKey || attemptedEpochs.has(attemptKey) || !isChatEpochConflict(error) || typeof reconcileEpoch !== "function") {
+        throw error;
+      }
+      attemptedEpochs.add(attemptKey);
+      await reconcileEpoch(chatId);
+      const nextEpoch = currentEpoch(readOptions());
+      if (!nextEpoch || nextEpoch.epochVersion <= epoch.epochVersion || nextEpoch.epochId === epoch.epochId) {
+        throw error;
+      }
+      onEpochAdvance?.({
+        fromEpochId: epoch.epochId,
+        fromEpochVersion: epoch.epochVersion,
+        toEpochId: nextEpoch.epochId,
+        toEpochVersion: nextEpoch.epochVersion
+      });
+    } finally {
+      release();
+    }
+  }
 }
 function markSendPerf(diag, label, startedAt, data = {}, minMs = SEND_CHAT_REDUCER_WARN_MS) {
   const elapsedMs = Date.now() - startedAt;
@@ -20305,7 +20557,7 @@ async function makeSharedMediaAttachment(cloud, media, message, data) {
     ...source?.c ? { caption: source.c } : {}
   }));
 }
-function createChatSend({ cloud, media = {}, uid, chatBanned, chatPK, chatSigningPK, chatSigningSecret, chatPrivateKey, notificationPK, notificationPrivateKey, localCache, localByChatRef, setLocalByChat, setChats, setLastChat, sendOptionsForPeer, selectLocalChat, adoptLocalMessageMedia, readMessageFile, mutationGate, diag = null }) {
+function createChatSend({ cloud, media = {}, uid, chatBanned, chatPK, chatSigningPK, chatSigningSecret, chatPrivateKey, notificationPK, notificationPrivateKey, localCache, localByChatRef, setLocalByChat, setChats, setLastChat, sendOptionsForPeer, selectLocalChat, adoptLocalMessageMedia, readMessageFile, mutationGate, reconcileEpoch, diag = null }) {
   const adoptedLocalMediaRef = { current: new Set };
   const attachmentPrepareByCidRef = { current: new Map };
   const cachedLocalMediaRef = { current: new Set };
@@ -20665,78 +20917,80 @@ ${cid}` : "";
   };
   const queueSend = async (peerChatPK, message, run, { previewRequired = false, sendOptions: sendOptionOverrides = null } = {}) => {
     const startedAt = Date.now();
-    let sendOptions = refreshQueuedSendOptions(sendOptionsForPeer, peerChatPK, sendOptionOverrides);
-    let local = await showLocalMessage(peerChatPK, message, sendOptions);
+    const sendOptions = refreshQueuedSendOptions(sendOptionsForPeer, peerChatPK, sendOptionOverrides);
+    const local = await showLocalMessage(peerChatPK, message, sendOptions);
     const mutationTarget = local.chatId || cleanText(sendOptionOverrides?.chatId) || peerChatPK;
-    let releaseMutation;
-    try {
-      releaseMutation = await mutationGate?.acquireShared(mutationTarget) || (() => {});
-    } catch (error) {
-      markLocalStatus(local.chatId, local.cid, LOCAL_FAILED);
-      throw error;
-    }
-    try {
-      sendOptions = refreshQueuedSendOptions(sendOptionsForPeer, peerChatPK, {
-        ...sendOptionOverrides,
-        chatId: local.chatId
-      });
-      const requiredPreview = previewRequired || sendOptions.chatExists !== true;
-      let committed = false;
-      let sent = false;
-      const markSent = () => {
-        if (sent)
-          return;
-        sent = true;
-        sentChatIdsRef.current.add(local.chatId);
-        markLocalStatus(local.chatId, local.cid, LOCAL_SENT);
-      };
-      const markCommitted = () => {
-        if (committed)
-          return;
-        committed = true;
-        markSent();
-        markDone(diag, "chat.send.commit", startedAt, { type: local?.t || "txt", previewRequired: !!requiredPreview });
-      };
-      return await new Promise((resolve, reject) => {
-        const job = {
-          previewKey: local.chatId,
-          previewRequired: requiredPreview,
-          resolve,
-          reject,
-          onSuccess: markSent,
-          onError: (error) => {
-            markError(diag, "chat.send.job", startedAt, error, { type: local?.t || "txt", previewRequired: !!requiredPreview });
-            if (committed)
-              markSent();
-            else
-              markLocalStatus(local.chatId, local.cid, LOCAL_FAILED);
-          },
-          run: async (context) => {
-            const writeStartedAt = Date.now();
-            const onCommitted = () => {
-              markCommitted();
-              context?.releaseTargets?.();
-            };
-            markDiag(diag, "chat.send.write.start", { type: local?.t || "txt", previewRequired: !!requiredPreview, updatePreview: !!context?.updatePreview });
-            try {
-              const result = await run({ ...context, local, onCommitted, sendOptions });
-              markDone(diag, "chat.send.write", writeStartedAt, { type: local?.t || "txt", previewRequired: !!requiredPreview, updatePreview: !!context?.updatePreview });
-              return result;
-            } catch (error) {
-              markError(diag, "chat.send.write", writeStartedAt, error, {
-                type: local?.t || "txt",
-                previewRequired: !!requiredPreview,
-                updatePreview: !!context?.updatePreview
-              });
-              throw error;
-            }
+    const requiredPreview = previewRequired || sendOptions.chatExists !== true;
+    let committed = false;
+    let sent = false;
+    const markSent = () => {
+      if (sent)
+        return;
+      sent = true;
+      sentChatIdsRef.current.add(local.chatId);
+      markLocalStatus(local.chatId, local.cid, LOCAL_SENT);
+    };
+    const markCommitted = () => {
+      if (committed)
+        return;
+      committed = true;
+      markSent();
+      markDone(diag, "chat.send.commit", startedAt, { type: local?.t || "txt", previewRequired: !!requiredPreview });
+    };
+    return await new Promise((resolve, reject) => {
+      const job = {
+        previewKey: local.chatId,
+        previewRequired: requiredPreview,
+        resolve,
+        reject,
+        onSuccess: markSent,
+        onError: (error) => {
+          markError(diag, "chat.send.job", startedAt, error, { type: local?.t || "txt", previewRequired: !!requiredPreview });
+          if (committed)
+            markSent();
+          else
+            markLocalStatus(local.chatId, local.cid, LOCAL_FAILED);
+        },
+        run: async (context) => {
+          const writeStartedAt = Date.now();
+          markDiag(diag, "chat.send.write.start", { type: local?.t || "txt", previewRequired: !!requiredPreview, updatePreview: !!context?.updatePreview });
+          try {
+            const result = await runCurrentEpochWrite({
+              chatId: mutationTarget,
+              mutationGate,
+              readOptions: () => refreshQueuedSendOptions(sendOptionsForPeer, peerChatPK, {
+                ...sendOptionOverrides,
+                chatId: local.chatId
+              }),
+              reconcileEpoch,
+              write: (currentSendOptions, onCommitted) => run({
+                ...context,
+                local,
+                onCommitted,
+                sendOptions: currentSendOptions
+              }),
+              onCommitted: () => {
+                markCommitted();
+                context?.releaseTargets?.();
+              },
+              onEpochAdvance: ({ fromEpochVersion, toEpochVersion }) => {
+                markDiag(diag, "chat.send.epoch.advance", { fromEpochVersion, toEpochVersion });
+              }
+            });
+            markDone(diag, "chat.send.write", writeStartedAt, { type: local?.t || "txt", previewRequired: !!requiredPreview, updatePreview: !!context?.updatePreview });
+            return result;
+          } catch (error) {
+            markError(diag, "chat.send.write", writeStartedAt, error, {
+              type: local?.t || "txt",
+              previewRequired: !!requiredPreview,
+              updatePreview: !!context?.updatePreview
+            });
+            throw error;
           }
-        };
-        enqueueSendJob(peerChatPK, job, reject);
-      });
-    } finally {
-      releaseMutation?.();
-    }
+        }
+      };
+      enqueueSendJob(peerChatPK, job, reject);
+    });
   };
   const sendOptionsForQueuedWrite = (baseOptions, local, updatePreview, onCommitted) => {
     const chatId = local?.chatId;
@@ -23490,7 +23744,7 @@ async function openChatReceiptCheckpoint(epoch, record) {
     cleanBytes(keys.key, plaintext);
   }
 }
-var CHAT_RECEIPT_CHECKPOINT_VERSION = 1, CHAT_RECEIPT_CHECKPOINT_MAX_BYTES = 4096, CHECKPOINT_BODY_VERSION = 1, CHECKPOINT_BODY_SUITE = 1, CHECKPOINT_HEADER_BYTES, CHECKPOINT_SIGN_SCOPE;
+var CHAT_RECEIPT_CHECKPOINT_VERSION = 2, CHAT_RECEIPT_CHECKPOINT_MAX_BYTES, CHECKPOINT_BODY_VERSION = 1, CHECKPOINT_BODY_SUITE = 1, CHECKPOINT_HEADER_BYTES, CHECKPOINT_SIGN_SCOPE;
 var init_chatreceipt = __esm(() => {
   init_box();
   init_canonical();
@@ -23502,8 +23756,9 @@ var init_chatreceipt = __esm(() => {
   init_protocol();
   init_receipt();
   "use client";
+  CHAT_RECEIPT_CHECKPOINT_MAX_BYTES = 16 * 1024;
   CHECKPOINT_HEADER_BYTES = 2 + BOX_NONCE_BYTES;
-  CHECKPOINT_SIGN_SCOPE = encoder.encode("veyl-chat-receipt-checkpoint-v3-sign");
+  CHECKPOINT_SIGN_SCOPE = encoder.encode("veyl-chat-receipt-checkpoint-v4-sign");
 });
 
 // ../../core/chat/receiptsession.js
@@ -23590,6 +23845,7 @@ function createChatReceiptSession({ cloud, epochState, identity, onUpdate, onErr
   let closed = false;
   let closing = false;
   let checkpoint = null;
+  let displayedProjection = null;
   let sourceProjection = null;
   let sourceStop = null;
   let sourceLeaseTimer = null;
@@ -23655,8 +23911,10 @@ function createChatReceiptSession({ cloud, epochState, identity, onUpdate, onErr
     checkpoint = next;
     if (closing || closed)
       return;
-    if (next)
-      onUpdate?.(projected(next));
+    if (next) {
+      displayedProjection = mergeChatReceiptProjections(displayedProjection, next.projection);
+      onUpdate?.(projected({ ...next, projection: displayedProjection }));
+    }
     if (coversDesired(next)) {
       desiredState = null;
       clearStalledClaimTimer();
@@ -23669,10 +23927,10 @@ function createChatReceiptSession({ cloud, epochState, identity, onUpdate, onErr
     else
       armSourceExpiry();
   };
-  const writeCheckpoint = async (mode, expectedVersion = null) => {
-    if (closed || closing)
+  const writeCheckpoint = async (mode, expectedVersion = null, projectionOverride = null) => {
+    if (closed || closing && mode !== "release")
       return false;
-    const desiredProjection = mode === "publish" ? sourceProjection : null;
+    const desiredProjection = mode === "publish" || mode === "release" ? projectionOverride || sourceProjection : null;
     const result = await cloud.chat.memberState.write({
       epochId: epoch.epochId,
       lane: address.lane,
@@ -23683,19 +23941,22 @@ function createChatReceiptSession({ cloud, epochState, identity, onUpdate, onErr
         const current = record ? await openChatReceiptCheckpoint(epoch, record).catch(() => null) : null;
         const heldByOther = !holdsLease(current, now) && Number(current?.leaseUntil) > now;
         const stalledTakeover = mode === "claim" && expectedVersion && checkpointVersion(current) === expectedVersion && !coversDesired(current);
+        if (mode === "release" && !holdsLease(current, now)) {
+          return { result: { won: false, checkpoint: current } };
+        }
         if (heldByOther && !stalledTakeover)
           return { result: { won: false, checkpoint: current } };
-        const projection = desiredProjection || current?.projection || buildChatReceiptProjection(epoch.manifest, new Map);
+        const projection = desiredProjection ? mergeChatReceiptProjections(current?.projection, desiredProjection) : current?.projection || buildChatReceiptProjection(epoch.manifest, new Map);
         if (mode === "publish" && holdsLease(current, now) && chatReceiptProjectionFingerprint(current.projection) === chatReceiptProjectionFingerprint(projection)) {
           return { result: { won: true, checkpoint: current } };
         }
         const term = current ? current.term + (!holdsLease(current, now) || Number(current.leaseUntil) <= now ? 1 : 0) : 1;
         const sealed = await sealChatReceiptCheckpoint(epoch, {
-          v: 1,
+          v: CHAT_RECEIPT_CHECKPOINT_VERSION,
           coordinator: epoch.actor.chatPK,
           holder,
           term,
-          leaseUntil: now + RECEIPT_COORDINATOR_LEASE_MS,
+          leaseUntil: mode === "release" ? now : now + RECEIPT_COORDINATOR_LEASE_MS,
           publishedAt: now,
           projection
         });
@@ -23745,10 +24006,10 @@ function createChatReceiptSession({ cloud, epochState, identity, onUpdate, onErr
     sourceStop = watchChatMemberStateEvidence(cloud, epochState, ({ states }) => {
       if (closed || closing || !holdsLease(checkpoint))
         return;
-      const nextProjection = buildChatReceiptProjection(epoch.manifest, states);
-      sourceProjection = nextProjection;
+      sourceProjection = mergeChatReceiptProjections(checkpoint?.projection, buildChatReceiptProjection(epoch.manifest, states));
+      displayedProjection = mergeChatReceiptProjections(displayedProjection, sourceProjection);
       onUpdate?.(projectChatReceiptCheckpoint(epoch.manifest, {
-        projection: sourceProjection,
+        projection: displayedProjection,
         publishedAt: Date.now()
       }));
       schedulePublish();
@@ -23838,6 +24099,8 @@ function createChatReceiptSession({ cloud, epochState, identity, onUpdate, onErr
       if (closed || closing)
         return;
       closing = true;
+      const finalProjection = sourceProjection;
+      const release = holdsLease(checkpoint) ? track(writeCheckpoint("release", null, finalProjection)) : null;
       watchRun += 1;
       clearClaimTimer();
       clearStalledClaimTimer();
@@ -23851,7 +24114,7 @@ function createChatReceiptSession({ cloud, epochState, identity, onUpdate, onErr
         closing = false;
         closeReceiptEpoch(opened);
       };
-      Promise.allSettled([...operations]).finally(finish);
+      Promise.allSettled([...operations, release].filter(Boolean)).finally(finish);
     }
   };
 }
@@ -24923,6 +25186,62 @@ var init_session2 = __esm(() => {
   init_receiptsession();
 });
 
+// ../../core/chat/retirement.js
+function planChatRetirement(chat, selfChatPK) {
+  const self2 = cleanText(selfChatPK);
+  const members = Array.isArray(chat?.members) ? chat.members : [];
+  const remaining = members.filter((member) => cleanText(member?.chatPK) !== self2);
+  const direct = chat?.lineage === CHAT_LINEAGES.DIRECT && members.length === 2;
+  return {
+    action: direct || !remaining.length ? CHAT_RETIREMENT_ACTIONS.DELETE : CHAT_RETIREMENT_ACTIONS.LEAVE,
+    remaining
+  };
+}
+async function retireChatMembershipOwner(cloud, identity, entry, fields = {}) {
+  const parent = entry?.current?.manifest;
+  const kind = fields.kind;
+  const epochVersion = fields.epochVersion;
+  if (!parent?.chatId || !identity?.uid || !identity?.chatPrivateKey || !Object.values(CHAT_OWNER_RETIREMENT_KINDS).includes(kind) || !Number.isSafeInteger(epochVersion)) {
+    throw new Error("chat membership retirement required");
+  }
+  const entryId = ownChatEntryId(identity.chatPrivateKey, parent.chatId);
+  const historyId = ownEpochEntryId(identity.chatPrivateKey, parent.chatId, parent.epochId);
+  const cutoffMs = Number.isFinite(fields.cutoffMs) ? fields.cutoffMs : Date.now();
+  const history = makeOwnerEpochRecord(parent, entry.current.epochSecret, {
+    cutoffMs,
+    successorTransitionCommitment: fields.successorTransitionCommitment,
+    successorTransitionMessageId: fields.successorTransitionMessageId,
+    leaveProposalId: fields.leaveProposalId
+  });
+  return retireOwnChatEntry(cloud, identity, entryId, entry, {
+    expectedEpochVersion: parent.epochVersion,
+    retirement: {
+      kind,
+      epochVersion,
+      ...kind === CHAT_OWNER_RETIREMENT_KINDS.LEAVE ? { proposalId: fields.leaveProposalId } : {}
+    },
+    epoch: {
+      id: historyId,
+      record: {
+        body: await sealOwnerEpochRecord(identity.chatPrivateKey, entryId, historyId, history),
+        tsMs: cutoffMs
+      }
+    },
+    mlsStateId: ownerChatMlsSnapshotId(identity, entryId, entry.current)
+  });
+}
+var CHAT_RETIREMENT_ACTIONS;
+var init_retirement = __esm(() => {
+  init_entry();
+  init_manifest();
+  init_owner2();
+  init_owner();
+  CHAT_RETIREMENT_ACTIONS = Object.freeze({
+    DELETE: "delete",
+    LEAVE: "leave"
+  });
+});
+
 // ../../core/chat/inbox.js
 function normalizeChatPreview(record, message) {
   if (!message || typeof message !== "object")
@@ -24972,7 +25291,7 @@ async function unlinkBlockedChat(cloud, uid, identity, entry, options) {
   const entryId = ownChatEntryId(identity.chatPrivateKey, manifest.chatId);
   markDiag(options.diag, "chat.owner.unlink", { reason: "blocked" });
   await cloud.user.chats.unlink(uid, entryId);
-  options.onRemoved?.(manifest.chatId);
+  options.onRemoved?.(manifest.chatId, manifest.epochVersion);
   options.onPingDelete?.(manifest.chatId);
   return { removed: true, blocked: true, chatId: manifest.chatId };
 }
@@ -24991,6 +25310,25 @@ function isRetryableInboxError(error) {
   ];
   return retryableCodes.some((value) => code === value || code.endsWith(`/${value}`)) || /\b(network|offline|timed? out|temporar(?:y|ily)|connection)\b/.test(message);
 }
+async function retireConfirmedDeletedChat(cloud, uid, identity, entry, options = {}) {
+  const manifest = entry?.current?.manifest;
+  if (!manifest?.chatId || !identity?.chatPrivateKey || !identity?.chatPK) {
+    throw new Error("deleted chat owner entry required");
+  }
+  const entryId = ownChatEntryId(identity.chatPrivateKey, manifest.chatId);
+  await cloud.user.chats.unlinkDeleted(uid, entryId, manifest.chatId);
+  if (entry.deliveryRegistered) {
+    const capability = deriveChatDeliveryCapability(entry.current.stateCapability, {
+      chatId: manifest.chatId,
+      recipientChatPK: identity.chatPK,
+      generation: manifest.epochVersion
+    });
+    await cloud.delivery.revoke(capability).catch(() => false);
+  }
+  markDiag(options.diag, "chat.owner.unlink", { reason: "confirmed_deleted" });
+  options.onPingDelete?.(manifest.chatId);
+  return { removed: true, deleted: true, chatId: manifest.chatId };
+}
 function inboxErrorReason(error) {
   const message = cleanText(error?.message).toLowerCase();
   if (message === "ping sender identity mismatch")
@@ -25205,7 +25543,7 @@ function sameRoutes(left, right) {
   return leftKeys.length === rightKeys.length && leftKeys.every((key) => sameRoute(left[key], right[key]));
 }
 function sameStableEntry(left, right) {
-  return !!left && !!right && left.current?.manifest?.epochId === right.current?.manifest?.epochId && left.current?.settings?.digest === right.current?.settings?.digest && sameRoutes(left.routes, right.routes) && left.deliveryRegistered === right.deliveryRegistered && left.notificationTag === right.notificationTag;
+  return !!left && !!right && left.current?.manifest?.epochId === right.current?.manifest?.epochId && left.current?.settings?.digest === right.current?.settings?.digest && sameRoutes(left.routes, right.routes) && left.deliveryRegistered === right.deliveryRegistered && left.notificationTag === right.notificationTag && left.retirement?.kind === right.retirement?.kind && left.retirement?.epochVersion === right.retirement?.epochVersion;
 }
 function projectOwnChatEntry(entry, entryId, userChatPK, ts, activity = {}) {
   const manifest = entry.current.manifest;
@@ -25255,20 +25593,43 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
   }
   let knownMember = entry?.current?.manifest?.members?.find((member) => member.chatPK === payload.senderChatPK) || null;
   const senderProfile = openedProfile || (knownMember ? { ...knownMember, uid: knownMember.uid } : null) || await resolveSenderProfile(cloud, payload);
-  if (entry && payload.epochVersion === entry.current.manifest.epochVersion && cleanText(payload.messageId) && cleanText(currentChat?.inboxMessageId) === cleanText(payload.messageId)) {
+  let restoringMembership = !!entry?.retirement;
+  if (restoringMembership && (payload.kind !== "welcome" || payload.epochVersion <= entry.retirement.epochVersion)) {
+    return "stale";
+  }
+  if (entry && !restoringMembership && payload.epochVersion === entry.current.manifest.epochVersion && cleanText(payload.messageId) && cleanText(currentChat?.inboxMessageId) === cleanText(payload.messageId)) {
     return "duplicate";
   }
-  if (entry && payload.epochVersion < entry.current.manifest.epochVersion) {
+  if (entry && !restoringMembership && payload.epochVersion < entry.current.manifest.epochVersion) {
     return "stale";
   }
-  if (entry && payload.epochVersion > entry.current.manifest.epochVersion) {
-    const advanced = await advanceEntryToEpoch(cloud, uid, identity, entry, payload.epochVersion, options);
+  if (entry && !restoringMembership && payload.epochVersion > entry.current.manifest.epochVersion) {
+    let advanced;
+    try {
+      advanced = await advanceEntryToEpoch(cloud, uid, identity, entry, payload.epochVersion, options);
+    } catch (error) {
+      if (payload.kind !== "chat_deleted")
+        throw error;
+      try {
+        await retireConfirmedDeletedChat(cloud, uid, identity, entry, options);
+        return "deleted";
+      } catch (confirmationError) {
+        if (isRetryableInboxError(confirmationError))
+          throw confirmationError;
+        throw error;
+      }
+    }
     if (advanced?.removed) {
-      options.onPingDelete?.(payload.chatId);
-      return "deleted";
+      if (payload.kind !== "welcome" || payload.epochVersion <= advanced.entry?.retirement?.epochVersion) {
+        options.onPingDelete?.(payload.chatId);
+        return "deleted";
+      }
+      entry = advanced.entry;
+      restoringMembership = true;
+    } else {
+      entry = advanced;
+      knownMember = entry.current.manifest.members.find((member) => member.chatPK === payload.senderChatPK) || null;
     }
-    entry = advanced;
-    knownMember = entry.current.manifest.members.find((member) => member.chatPK === payload.senderChatPK) || null;
   }
   if (payload.kind === "chat_deleted") {
     if (!entry || entry.current.manifest.epochId !== payload.epochId || entry.current.manifest.epochVersion !== payload.epochVersion || !knownMember) {
@@ -25288,7 +25649,7 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
     return "deleted";
   }
   let epochState = entry?.current || null;
-  if (!entry && payload.kind === "welcome") {
+  if ((!entry || restoringMembership) && payload.kind === "welcome") {
     epochState = await welcomedEpochFromPing(cloud, identity, senderProfile, payload, options);
   } else if (!entry) {
     throw new Error("chat mls welcome required");
@@ -25318,6 +25679,11 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
         options.onPingDelete?.(payload.chatId);
         return "deleted";
       }
+      const latest = await advanceEntryToLatestEpoch(cloud, uid, identity, transitioned, options);
+      if (latest?.removed) {
+        options.onPingDelete?.(payload.chatId);
+        return "deleted";
+      }
       return "transition";
     }
   }
@@ -25331,7 +25697,7 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
   const routes = withSenderRoute(entry, payload, senderProfile, epochState);
   const preview2 = nextPreview(currentChat, record, message, payload);
   const nowMs2 = timestampMs(record?.ts, null) ?? timestampMs(payload.ts, Date.now()) ?? Date.now();
-  const membershipWelcome = !entry && payload.kind === "welcome";
+  const membershipWelcome = (!entry || restoringMembership) && payload.kind === "welcome";
   const projectedTsMs = membershipWelcome ? Date.now() : nowMs2;
   let deliveryRegistered = entry?.deliveryRegistered === true;
   if (!deliveryRegistered)
@@ -25349,7 +25715,8 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
     },
     routes,
     deliveryRegistered,
-    notificationTag: notificationChatTag(epochState.stateCapability, payload.chatId, identity.chatPK)
+    notificationTag: notificationChatTag(epochState.stateCapability, payload.chatId, identity.chatPK),
+    retirement: null
   } : makeOwnChatEntry(epochState, {
     routes,
     startMs: nowMs2,
@@ -25365,6 +25732,9 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
         ...welcomeMlsState ? { mlsWrites: [{ id: welcomeMlsState.stateId, value: welcomeMlsState.value }] } : {}
       };
     }
+    if (membershipWelcome && current.retirement && epochState.manifest.epochVersion <= current.retirement.epochVersion) {
+      throw new Error("chat welcome is not newer than retirement");
+    }
     if (current.current.manifest.epochVersion > epochState.manifest.epochVersion) {
       return { result: current };
     }
@@ -25373,7 +25743,8 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
       current: nextEntry.current,
       routes: withSenderRoute(current, payload, senderProfile, epochState),
       deliveryRegistered: current.deliveryRegistered || nextEntry.deliveryRegistered,
-      notificationTag: nextEntry.notificationTag
+      notificationTag: nextEntry.notificationTag,
+      retirement: membershipWelcome ? null : current.retirement
     };
     if (sameStableEntry(current, candidate) && !welcomeMlsState)
       return { result: current };
@@ -25383,6 +25754,9 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
       ...welcomeMlsState ? { mlsWrites: [{ id: welcomeMlsState.stateId, value: welcomeMlsState.value }] } : {}
     };
   }) : entry;
+  if (committedEntry?.retirement) {
+    throw new Error("chat membership remains retired");
+  }
   if (membershipWelcome && epochState.mlsSnapshot) {
     if (!epochState.mlsKeyPackageLastResort) {
       await cloud.user.mls.keyPackages.deleteState(identity.uid, epochState.mlsKeyPackageId).catch(() => false);
@@ -25426,8 +25800,15 @@ async function processPing(cloud, uid, identity, doc, options) {
 async function applyEpochTransitionAction(cloud, uid, identityValue, entry, action, options, confirmedValue = null) {
   const parent = entry.current.manifest;
   const sender = manifestMember(parent, action.s || action.certificate?.actor);
-  if (!sender)
+  const reject = (stage) => {
+    markDiag(options.diag, "chat.epoch.apply.reject", {
+      stage,
+      epochVersion: parent.epochVersion
+    });
     return null;
+  };
+  if (!sender)
+    return reject("sender");
   const engine = await options.mls?.open?.();
   if (!engine)
     throw new Error("mls engine required");
@@ -25435,25 +25816,25 @@ async function applyEpochTransitionAction(cloud, uid, identityValue, entry, acti
   const expectedCommitment = transitionCommitment(action.certificate);
   const confirmed = confirmedValue || await cloud.chat.state.transition(parent.chatId, parent.epochId, entry.current.stateCapability).catch(() => null);
   if (!confirmed || confirmed.parentEpochVersion !== parent.epochVersion || confirmed.nextEpochId !== action.certificate?.nextEpochId || confirmed.nextEpochVersion !== action.certificate?.nextEpochVersion || confirmed.transitionCommitment !== expectedCommitment || confirmed.transitionMessageId !== messageId || confirmed.mlsPackageId !== action.mls?.packageId || confirmed.mlsPackageDigest !== action.mls?.packageDigest)
-    return null;
+    return reject("certificate");
   let leaveProposalId = "";
   if (action.membership?.kind === "leave") {
     const leavingChatPK = cleanText(action.membership?.actor);
     const proposalId = cleanText(action.membership?.proposalId);
     const targetSet = new Set(Array.isArray(action.membership?.targets) ? action.membership.targets.map(cleanText) : []);
     if (!leavingChatPK || !proposalId || targetSet.size !== 1 || !targetSet.has(leavingChatPK))
-      return null;
+      return reject("leave-certificate");
     const proposalRecord = await cloud.chat.messages.read(parent.epochId, proposalId, {
       lane: messageLaneForEpoch(entry.current)
     }).catch(() => null);
     const proposal = proposalRecord ? await decryptMsg(proposalRecord, "", "", "", { chatId: parent.chatId, epochState: entry.current }).catch(() => null) : null;
     if (!isLeaveProposalMsg(proposal) || proposal.s !== leavingChatPK)
-      return null;
+      return reject("leave-proposal");
     leaveProposalId = proposalId;
   }
   const packageRecord = await cloud.chat.mls.packages.read(parent.chatId, confirmed.mlsPackageId);
   if (!packageRecord || packageRecord.digest !== confirmed.mlsPackageDigest || packageRecord.head.transitionCommitment !== confirmed.transitionCommitment || !verifyChatMlsEpochPackageSignature(packageRecord, sender.chatSigningPK))
-    return null;
+    return reject("mls-package");
   const identity = {
     ...identityValue,
     uid,
@@ -25464,8 +25845,11 @@ async function applyEpochTransitionAction(cloud, uid, identityValue, entry, acti
   let parentSnapshot = null;
   let nextSnapshot = null;
   let epochState = null;
+  let openStage = "owner-snapshot";
+  const openStartedAt = Date.now();
   try {
     parentSnapshot = await readOwnerChatMlsSnapshot(cloud, identity, entryId, entry.current);
+    openStage = "mls-commit";
     const processed = engine.processCommit(parentSnapshot, packageRecord.commit);
     nextSnapshot = processed.snapshot;
     if (processed.removed) {
@@ -25477,16 +25861,21 @@ async function applyEpochTransitionAction(cloud, uid, identityValue, entry, acti
         });
         await cloud.delivery.revoke(capability).catch(() => false);
       }
-      if (options.wasRemoved?.(parent.chatId) !== true) {
-        markDiag(options.diag, "chat.owner.unlink", { reason: "membership" });
-        await cloud.user.chats.unlink(uid, entryId);
-      }
+      markDiag(options.diag, "chat.owner.retire", { reason: "membership" });
+      const retiredEntry = await retireChatMembershipOwner(cloud, identity, entry, {
+        kind: CHAT_OWNER_RETIREMENT_KINDS.REMOVED,
+        epochVersion: confirmed.nextEpochVersion,
+        cutoffMs: Date.now(),
+        successorTransitionCommitment: confirmed.transitionCommitment,
+        successorTransitionMessageId: messageId
+      });
       if (leaveProposalId) {
         options.leaveProposalObservedAt?.delete(`${parent.chatId}:${leaveProposalId}`);
       }
-      options.onRemoved?.(parent.chatId);
-      return { removed: true, chatId: parent.chatId };
+      options.onRemoved?.(parent.chatId, confirmed.nextEpochVersion);
+      return { removed: true, chatId: parent.chatId, entry: retiredEntry };
     }
+    openStage = "mls-package-open";
     const opened = await openChatMlsEpochPackage(processed, packageRecord, {
       chatId: parent.chatId,
       senderSigningPK: sender.chatSigningPK,
@@ -25501,8 +25890,13 @@ async function applyEpochTransitionAction(cloud, uid, identityValue, entry, acti
       mlsPackageId: opened.packageId,
       mlsPackageDigest: opened.packageDigest
     };
+    openStage = "settings";
     epochState.settings = await readEpochChatSettings(cloud, epochState);
-  } catch {
+  } catch (error) {
+    markError(options.diag, "chat.epoch.apply", openStartedAt, error, {
+      stage: openStage,
+      epochVersion: parent.epochVersion
+    });
     cleanBytes(parentSnapshot, nextSnapshot, epochState?.epochSecret, epochState?.stateCapability);
     return null;
   }
@@ -25589,6 +25983,42 @@ async function advanceEntryToEpoch(cloud, uid, identity, entry, targetEpochVersi
     }).catch(() => null);
     const action = record ? await decryptMsg(record, "", "", "", { chatId: parent.chatId, epochState: current.current }).catch(() => null) : null;
     if (!isEpochTransitionMsg(action)) {
+      markDiag(options.diag, "chat.epoch.advance.pending", {
+        stage: record ? "transition-open" : "transition-record",
+        epochVersion: parent.epochVersion
+      });
+      const error = new Error("chat epoch transition message is not available yet");
+      error.code = "chat/epoch-pending";
+      throw error;
+    }
+    const advanced = await applyEpochTransitionAction(cloud, uid, identity, current, action, options, confirmed);
+    if (advanced?.removed)
+      return advanced;
+    if (!advanced?.current?.manifest || advanced.current.manifest.epochVersion <= parent.epochVersion) {
+      const error = new Error("chat epoch transition could not be verified");
+      error.code = "chat/epoch-pending";
+      throw error;
+    }
+    current = advanced;
+  }
+  return current;
+}
+async function advanceEntryToLatestEpoch(cloud, uid, identity, entry, options = {}) {
+  let current = entry;
+  while (current?.current?.manifest) {
+    const parent = current.current.manifest;
+    const confirmed = await cloud.chat.state.transition(parent.chatId, parent.epochId, current.current.stateCapability);
+    if (!confirmed?.transitionMessageId)
+      return current;
+    const record = await cloud.chat.messages.read(parent.epochId, confirmed.transitionMessageId, {
+      lane: messageLaneForEpoch(current.current)
+    }).catch(() => null);
+    const action = record ? await decryptMsg(record, "", "", "", { chatId: parent.chatId, epochState: current.current }).catch(() => null) : null;
+    if (!isEpochTransitionMsg(action)) {
+      markDiag(options.diag, "chat.epoch.advance.pending", {
+        stage: record ? "transition-open" : "transition-record",
+        epochVersion: parent.epochVersion
+      });
       const error = new Error("chat epoch transition message is not available yet");
       error.code = "chat/epoch-pending";
       throw error;
@@ -25706,6 +26136,7 @@ var init_inbox2 = __esm(() => {
   init_membership();
   init_entry();
   init_owner();
+  init_retirement();
   init_manifest();
   init_state2();
   init_transition();
@@ -25725,6 +26156,17 @@ var init_inbox2 = __esm(() => {
 });
 
 // ../../core/chat/list.js
+function chatOwnerRevision(chat) {
+  return Number.isSafeInteger(chat?.ownEntry?.ownerRevision) ? chat.ownEntry.ownerRevision : 0;
+}
+function serverChatCoversOverlay(chat, overlay) {
+  const serverEpoch = Number.isSafeInteger(chat?.epochVersion) ? chat.epochVersion : 0;
+  const overlayEpoch = Number.isSafeInteger(overlay?.epochVersion) ? overlay.epochVersion : 0;
+  if (serverEpoch !== overlayEpoch) {
+    return serverEpoch > overlayEpoch;
+  }
+  return chatOwnerRevision(chat) >= chatOwnerRevision(overlay);
+}
 function inboxRetryKey(doc) {
   const id = typeof doc?.id === "string" ? doc.id : "";
   const ts = timestampMs(doc?.ts, 0) || 0;
@@ -25797,13 +26239,17 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
     nextAfterChat: null,
     hasMore: false
   };
-  const optimisticChats = new Map;
-  const mergedChats = (chats) => {
+  const optimisticChats = options.optimisticChats instanceof Map ? options.optimisticChats : new Map;
+  const mergedChats = (chats, mergeOptions = {}) => {
     const nextById = new Map;
     for (const chat of chats || []) {
       const optimistic = optimisticChats.get(chat?.id);
-      if (chat?.id)
+      if (chat?.id) {
         nextById.set(chat.id, mergeChatActivity(chat, optimistic, userChatPK));
+        if (mergeOptions.settle === true && optimistic && serverChatCoversOverlay(chat, optimistic)) {
+          optimisticChats.delete(chat.id);
+        }
+      }
     }
     for (const [id, chat] of optimisticChats.entries()) {
       if (!nextById.has(id)) {
@@ -25868,7 +26314,7 @@ function listenToChats(cloud, uid, userChatPK, userPrivKey, onUpdate, onError, o
       if (!closed && runId === run) {
         processedFirst = true;
         const chats = page.chats;
-        latestChats = mergedChats(chats);
+        latestChats = mergedChats(chats, { settle: true });
         latestMeta = {
           nextAfterChat: snapshot.nextAfterChat,
           hasMore: snapshot.hasMore
@@ -26111,6 +26557,9 @@ async function decryptChatEntry(entryRecord, userChatPK, userPrivKey) {
   if (entry.ownerRevision !== data?.revision) {
     throw new Error("chat owner revision mismatch");
   }
+  if (entry.retirement) {
+    return null;
+  }
   if (entry.protocol !== CHAT_PROTOCOL_VERSION) {
     return null;
   }
@@ -26250,6 +26699,7 @@ function createChatList({
   localByChatRef,
   pendingDeleteIdsRef,
   deletedChatIdsRef,
+  removedChatVersionsRef,
   keepSelectedDeletedChatIdsRef,
   readCacheRef,
   lastServerChatsRef,
@@ -26267,6 +26717,7 @@ function createChatList({
   onTransition,
   onRemoved,
   wasRemoved,
+  restoreRemovedChat,
   resetExternalChatState,
   mutationGate,
   onMlsKeyPackageConsumed
@@ -26295,6 +26746,8 @@ function createChatList({
   const cachedHistoryEndRef = { current: false };
   const cachedHistoryHeadRef = { current: [] };
   const previewTimerRef = { current: null };
+  const epochReconciliations = new Map;
+  const inboxOverlayChats = new Map;
   let listening = false;
   let unsubscribeChats = null;
   let snapshot = null;
@@ -26303,7 +26756,7 @@ function createChatList({
   let blockedUidSet = new Set(blockedUids);
   let schedulePreviewExpiry = () => {};
   let fillVisibleChatPage = () => {};
-  const isHiddenChatId = (chatId) => !!chatId && (pendingDeleteIdsRef.current.has(chatId) || deletedChatIdsRef.current.has(chatId));
+  const isHiddenChatId = (chatId) => !!chatId && (pendingDeleteIdsRef.current.has(chatId) || deletedChatIdsRef.current.has(chatId) || removedChatVersionsRef.current.has(chatId));
   const filterHiddenChats = (nextChats) => (nextChats || []).filter((chatItem) => chatItem?.id && !isHiddenChatId(chatItem.id));
   const nextValue = (current, next) => typeof next === "function" ? next(current) : next;
   const publish = () => {
@@ -26518,7 +26971,13 @@ function createChatList({
     return shownChats;
   };
   const applyInboxChat = (chat) => {
-    if (!chat?.id || isHiddenChatId(chat.id)) {
+    if (!chat?.id) {
+      return;
+    }
+    if (removedChatVersionsRef.current.has(chat.id)) {
+      restoreRemovedChat?.(chat);
+    }
+    if (isHiddenChatId(chat.id)) {
       return;
     }
     const updateStartedAt = Date.now();
@@ -26544,13 +27003,113 @@ function createChatList({
   const applyInboxDelete = (chatId) => {
     if (!chatId)
       return;
+    inboxOverlayChats.delete(chatId);
     pendingDeleteIdsRef.current.delete(chatId);
     commitServerChats(lastServerChatsRef.current.filter((chat) => chat?.id !== chatId), {
       warm: false
     });
     setSelectedChat((current) => current === chatId ? null : current);
   };
+  const reconcileChatEpoch = (chatId) => {
+    if (!chatId || !uid || !chatPK || !chatPrivateKey || !chatSigningPK || !chatSigningSecret || !notificationPK) {
+      return Promise.resolve({ advanced: false, chat: null, removed: false });
+    }
+    const active = epochReconciliations.get(chatId);
+    if (active)
+      return active;
+    let task;
+    task = (async () => {
+      const releaseMutation = await mutationGate?.acquireExclusive(chatId) || (() => {});
+      try {
+        const initial = getChatEntry(chatId);
+        if (!initial?.ownEntry)
+          return { advanced: false, chat: initial || null, removed: false };
+        const initialVersion = initial.epochVersion;
+        const identity = {
+          uid,
+          chatPK,
+          chatPrivateKey,
+          chatSigningPK,
+          chatSigningSecret,
+          notificationPK,
+          notificationPrivateKey
+        };
+        const advanceOptions = {
+          blockedUids: blockedUidSet,
+          mls,
+          diag,
+          onMlsKeyPackageConsumed,
+          onRemoved: (removedChatId, epochVersion) => {
+            onRemoved?.(removedChatId, epochVersion);
+            applyInboxDelete(removedChatId);
+          },
+          wasRemoved,
+          onTransition: (chat, message) => {
+            onTransition?.(chat, message);
+            applyInboxChat(chat);
+          }
+        };
+        let working = initial;
+        let result;
+        while (true) {
+          try {
+            result = await advanceEntryToLatestEpoch(cloud, uid, identity, working.ownEntry, advanceOptions);
+            break;
+          } catch (error) {
+            const code = String(error?.code || "").trim().toLowerCase();
+            if (code === "permission-denied" || code.endsWith("/permission-denied")) {
+              result = await retireConfirmedDeletedChat(cloud, uid, identity, working.ownEntry, {
+                diag,
+                onPingDelete: applyInboxDelete
+              });
+              break;
+            }
+            if (code !== "chat/epoch-pending")
+              throw error;
+            const canonical = await getChat(cloud, uid, chatId, chatPK, chatPrivateKey);
+            if (!canonical?.ownEntry || canonical.epochVersion <= working.epochVersion)
+              throw error;
+            markDiag(diag, "chat.epoch.reconcile.rebase", {
+              fromEpochVersion: working.epochVersion,
+              toEpochVersion: canonical.epochVersion
+            });
+            applyInboxChat(canonical);
+            working = canonical;
+          }
+        }
+        if (result?.removed) {
+          markDiag(diag, "chat.epoch.reconcile.done", {
+            fromEpochVersion: initialVersion,
+            removed: true
+          });
+          return { advanced: true, chat: null, removed: true };
+        }
+        const latest = getChatEntry(chatId);
+        const advanced = Number(latest?.epochVersion || 0) > Number(initialVersion || 0);
+        if (advanced) {
+          markDiag(diag, "chat.epoch.reconcile.done", {
+            fromEpochVersion: initialVersion,
+            toEpochVersion: latest.epochVersion,
+            removed: false
+          });
+        }
+        return {
+          advanced,
+          chat: latest || null,
+          removed: false
+        };
+      } finally {
+        releaseMutation();
+      }
+    })().finally(() => {
+      if (epochReconciliations.get(chatId) === task)
+        epochReconciliations.delete(chatId);
+    });
+    epochReconciliations.set(chatId, task);
+    return task;
+  };
   const resetChatList = (ready = false) => {
+    inboxOverlayChats.clear();
     chatSourceReady = ready;
     syncChatDataReady();
     setIsChatListLive(false);
@@ -26674,7 +27233,15 @@ function createChatList({
     };
     const unsubscribe = listenToChats(cloud, uid, chatPK, chatPrivateKey, (nextChats, _nextPeers, meta = {}) => {
       const updateStartedAt = Date.now();
-      const rawNextChats = filterHiddenChats(Array.isArray(nextChats) ? nextChats : []);
+      const incomingChats = Array.isArray(nextChats) ? nextChats : [];
+      if (meta?.source === "inbox") {
+        for (const chat of incomingChats) {
+          if (removedChatVersionsRef.current.has(chat?.id)) {
+            restoreRemovedChat?.(chat);
+          }
+        }
+      }
+      const rawNextChats = filterHiddenChats(incomingChats);
       hydrateReadCache(rawNextChats, readCacheRef.current);
       const readAppliedChats = applyReadCache(rawNextChats, chatPK, readCacheRef.current);
       const trimmedChats = trimExpiredChatPreviews(readAppliedChats, { skipChatId: selectedChatIdRef.current });
@@ -26779,6 +27346,7 @@ function createChatList({
       blockedUids: blockedUidSet,
       localCache,
       diag,
+      optimisticChats: inboxOverlayChats,
       getCurrentChat: (chatId) => lastServerChatsRef.current.find((chatItem) => chatItem?.id === chatId) || null,
       mutationGate,
       onMlsKeyPackageConsumed
@@ -26957,12 +27525,16 @@ function createChatList({
   };
   const hasChat = (chatId) => !!chatId && (serverChatIdsSet.has(chatId) || chatLoadsRef.current.has(chatId)) && !isHiddenChatId(chatId);
   const setSources = (nextSources) => {
+    const accountChanged = cloud !== nextSources.cloud || uid !== nextSources.uid || chatPK !== nextSources.chatPK || chatPrivateKey !== nextSources.chatPrivateKey;
     const nextBlocked = sortedUniqueValues(Array.isArray(nextSources.blocked) ? nextSources.blocked : []);
     const nextBlockedUidsKey = nextBlocked.join("|");
     const nextBlockedReady = nextSources.blockedReady === true;
     const blockedFilterChanged = blockedUidsKey !== nextBlockedUidsKey || blockedReady !== nextBlockedReady;
     const listenerChanged = cloud !== nextSources.cloud || uid !== nextSources.uid || chatPK !== nextSources.chatPK || chatSigningPK !== nextSources.chatSigningPK || chatSigningSecret !== nextSources.chatSigningSecret || chatPrivateKey !== nextSources.chatPrivateKey || notificationPK !== nextSources.notificationPK || notificationPrivateKey !== nextSources.notificationPrivateKey || mls !== nextSources.mls || chatBanned !== nextSources.chatBanned || localCache !== nextSources.localCache || isActive !== nextSources.isActive;
     const selectedChatChanged = selectedChatId !== nextSources.selectedChatId;
+    if (accountChanged) {
+      inboxOverlayChats.clear();
+    }
     ({
       cloud,
       uid,
@@ -26984,6 +27556,7 @@ function createChatList({
       localByChatRef,
       pendingDeleteIdsRef,
       deletedChatIdsRef,
+      removedChatVersionsRef,
       keepSelectedDeletedChatIdsRef,
       readCacheRef,
       lastServerChatsRef,
@@ -27001,6 +27574,7 @@ function createChatList({
       onTransition,
       onRemoved,
       wasRemoved,
+      restoreRemovedChat,
       resetExternalChatState,
       mutationGate,
       onMlsKeyPackageConsumed
@@ -27044,6 +27618,8 @@ function createChatList({
       previewTimerRef.current = null;
     }
     flushChatCacheWrite();
+    epochReconciliations.clear();
+    inboxOverlayChats.clear();
     subscribers.clear();
   };
   const subscribe = (subscriber) => {
@@ -27069,6 +27645,7 @@ function createChatList({
     getChatPreviewKey: getChatPreviewKey2,
     getChatRetention,
     getChatEntry,
+    reconcileChatEpoch,
     sendOptionsForPeer,
     hasChat
   };
@@ -27079,32 +27656,13 @@ var init_listsession = __esm(() => {
   init_localdata();
   init_chats();
   init_list();
+  init_inbox2();
   init_ttl();
   init_ids();
   init_time();
   CHAT_LIST_RESET_ERROR_CODES = new Set(["permission-denied", "unauthenticated"]);
 });
 
-// ../../core/chat/retirement.js
-function planChatRetirement(chat, selfChatPK) {
-  const self2 = cleanText(selfChatPK);
-  const members = Array.isArray(chat?.members) ? chat.members : [];
-  const remaining = members.filter((member) => cleanText(member?.chatPK) !== self2);
-  const direct = chat?.lineage === CHAT_LINEAGES.DIRECT && members.length === 2;
-  return {
-    action: direct || !remaining.length ? CHAT_RETIREMENT_ACTIONS.DELETE : CHAT_RETIREMENT_ACTIONS.LEAVE,
-    remaining
-  };
-}
-var CHAT_RETIREMENT_ACTIONS;
-var init_retirement = __esm(() => {
-  init_manifest();
-  CHAT_RETIREMENT_ACTIONS = Object.freeze({
-    DELETE: "delete",
-    LEAVE: "leave"
-  });
-});
-
 // ../../core/utils/appstate.js
 function isForegroundAppState(state) {
   const value = String(state || "").trim().toLowerCase();
@@ -27283,7 +27841,6 @@ function createChatSession({
   const closeMessageBatchRef = { current: null };
   const localMessageDiagRef = { current: "" };
   const epochHistoryRef = { current: new Map };
-  const epochRecoveryRef = { current: new Map };
   const settingsUpdateStatesRef = { current: new Map };
   const membershipUpdateStatesRef = { current: new Map };
   const directChatOpensRef = { current: new Map };
@@ -27322,6 +27879,7 @@ function createChatSession({
       kickChatMember,
       leaveChat,
       updateChatSettings: updateChatSettings2,
+      updateChatAvatar,
       dropChat,
       dropUnavailableChat,
       deleteChat,
@@ -27329,6 +27887,7 @@ function createChatSession({
       deleteAllChats,
       restoreDeletedChat,
       enterChatActivity,
+      flushChatReadFrontier,
       leaveChatActivity,
       markChatReadState,
       markChatRead,
@@ -27780,51 +28339,15 @@ function createChatSession({
     return true;
   };
   const handleBatchMessages = (chatId, messages) => {
-    const transition = [...messages || []].reverse().find(isEpochTransitionMsg);
-    const nextEpochId = transition?.certificate?.nextEpochId;
-    const chat = getChatEntry(chatId);
-    if (!nextEpochId || !chat?.ownEntry || chat.epochId === nextEpochId || epochRecoveryRef.current.has(nextEpochId))
+    if (![...messages || []].reverse().some(isEpochTransitionMsg))
       return;
-    const recover = (attempt = 0) => {
-      const timer = attempt > 0 ? setTimeout(run, [0, 250, 1000, 3000][attempt] || 3000) : null;
-      epochRecoveryRef.current.set(nextEpochId, timer || true);
-      if (!timer)
-        run();
-      async function run() {
-        let releaseMutation = () => {};
-        try {
-          releaseMutation = await mutationGate.acquireExclusive(chatId);
-          const current = getChatEntry(chatId);
-          if (!current?.ownEntry || current.epochId === nextEpochId)
-            return;
-          const advanced = await processEpochTransitionMessages(cloud, uid, {
-            chatPK,
-            chatPrivateKey,
-            notificationPK
-          }, current.ownEntry, messages, {
-            blockedUids: new Set(blocked),
-            notificationPrivateKey,
-            diag,
-            onRemoved: (removedChatId) => deleteActions.dropRemovedChat(removedChatId),
-            wasRemoved: (removedChatId) => deleteActions.deletedChatIdsRef.current.has(removedChatId),
-            onTransition: stageCommittedMembershipMessage
-          });
-          if (advanced)
-            epochHistoryRef.current.delete(chatId);
-          else if (attempt < 3)
-            return recover(attempt + 1);
-        } catch {
-          if (attempt < 3)
-            return recover(attempt + 1);
-        } finally {
-          releaseMutation();
-          if (epochRecoveryRef.current.get(nextEpochId) === (timer || true)) {
-            epochRecoveryRef.current.delete(nextEpochId);
-          }
-        }
-      }
-    };
-    recover();
+    const startedAt = Date.now();
+    chatListOwner.reconcileChatEpoch(chatId).then((result) => {
+      if (result.advanced)
+        epochHistoryRef.current.delete(chatId);
+    }).catch((error) => {
+      markError(diag, "chat.epoch.reconcile", startedAt, error);
+    });
   };
   const setChats = (...args) => chatListOwner.setChats(...args);
   const setLastChat = (...args) => chatListOwner.setLastChat(...args);
@@ -27842,11 +28365,6 @@ function createChatSession({
     liveActions?.close?.();
     liveActivityByChat = new Map;
     messageBatchOwner.clear();
-    for (const pending of epochRecoveryRef.current.values()) {
-      if (typeof pending === "number")
-        clearTimeout(pending);
-    }
-    epochRecoveryRef.current.clear();
     epochHistoryRef.current.clear();
     membershipUpdateStatesRef.current.clear();
     directChatOpensRef.current.clear();
@@ -28296,14 +28814,18 @@ function createChatSession({
           recipientChatPK: chatPK,
           generation: chat.epochVersion
         });
+        await retireChatMembershipOwner(cloud, transitionIdentity(), chat.ownEntry, {
+          kind: CHAT_OWNER_RETIREMENT_KINDS.LEAVE,
+          epochVersion: chat.epochVersion,
+          cutoffMs: Date.now(),
+          leaveProposalId: proposal.message.cid
+        });
         await cloud.delivery.revoke(capability).catch(() => false);
-        await discardOwnerChatMlsSnapshot(cloud, transitionIdentity(), chat.entryId, chat.epochState);
-        await cloud.user.chats.unlink(uid, chat.entryId);
         if (retirementStarted) {
-          deleteActions.commitRetirement(chatId);
+          deleteActions.commitRemovedRetirement(chatId, chat.epochVersion + 1);
           retirementStarted = false;
         } else {
-          deleteActions.dropChat(chatId);
+          deleteActions.dropRemovedChat(chatId, chat.epochVersion + 1);
         }
         return { left: true, message: proposal.message };
       } catch (error) {
@@ -28365,35 +28887,55 @@ function createChatSession({
         clearLocalMembershipMessage(chatId, cid);
     };
     state.promise = (async () => {
-      const releaseMutation = await mutationGate.acquireExclusive(chatId);
       try {
-        const chat = requireTransitionChat(chatId);
-        const members = prepareMembers ? await prepareMembers(chat) : resolveMembers(chat);
-        if (!members) {
-          restoreAuthoritativeChat();
-          return { entry: chat.ownEntry, unchanged: true };
-        }
-        if (!members.length) {
-          restoreAuthoritativeChat();
-          await deleteActions.deleteChat(chat);
-          return { deleted: true };
-        }
-        const result = await transitionChatEpoch(cloud, transitionIdentity(), chat.ownEntry, { members, cid, mls });
-        if (result.entry) {
-          const projected = projectOwnChatEntry(result.entry, chat.entryId, chatPK, chat.ts);
-          chatListOwner.commitServerChats(sortedChats([projected], lastServerChatsRef.current));
-        } else {
-          chatListOwner.commitServerChats(lastServerChatsRef.current.filter((chatItem) => chatItem?.id !== chatId), { warm: false });
-          setSelectedChat((current) => current === chatId ? null : current);
-        }
-        if (optimisticRoster && result.message) {
-          stageCommittedMembershipMessage(chat, result.message);
-        } else if (optimisticRoster) {
-          clearLocalMembershipMessage(chatId, cid);
+        while (true) {
+          const releaseMutation = await mutationGate.acquireExclusive(chatId);
+          let attemptedEpochVersion = 0;
+          try {
+            const chat = requireTransitionChat(chatId);
+            attemptedEpochVersion = chat.epochVersion;
+            const members = prepareMembers ? await prepareMembers(chat) : resolveMembers(chat);
+            if (!members) {
+              restoreAuthoritativeChat();
+              return { entry: chat.ownEntry, unchanged: true };
+            }
+            if (!members.length) {
+              restoreAuthoritativeChat();
+              await deleteActions.deleteChat(chat);
+              return { deleted: true };
+            }
+            const result = await transitionChatEpoch(cloud, transitionIdentity(), chat.ownEntry, { members, cid, mls });
+            if (result.entry) {
+              const projected = projectOwnChatEntry(result.entry, chat.entryId, chatPK, chat.ts);
+              chatListOwner.commitServerChats(sortedChats([projected], lastServerChatsRef.current));
+            } else {
+              chatListOwner.commitServerChats(lastServerChatsRef.current.filter((chatItem) => chatItem?.id !== chatId), { warm: false });
+              setSelectedChat((current) => current === chatId ? null : current);
+            }
+            if (optimisticRoster && result.message) {
+              stageCommittedMembershipMessage(chat, result.message);
+            } else if (optimisticRoster) {
+              clearLocalMembershipMessage(chatId, cid);
+            }
+            if (optimisticRoster)
+              setPendingChatMembers(chatId, null);
+            return result;
+          } catch (error) {
+            releaseMutation();
+            if (!attemptedEpochVersion || !isChatEpochConflict(error))
+              throw error;
+            await chatListOwner.reconcileChatEpoch(chatId);
+            const currentEpochVersion = getChatEntry(chatId)?.epochVersion || 0;
+            if (currentEpochVersion <= attemptedEpochVersion)
+              throw error;
+            markDiag(diag, "chat.membership.epoch.advance", {
+              fromEpochVersion: attemptedEpochVersion,
+              toEpochVersion: currentEpochVersion
+            });
+          } finally {
+            releaseMutation();
+          }
         }
-        if (optimisticRoster)
-          setPendingChatMembers(chatId, null);
-        return result;
       } catch (error) {
         restoreAuthoritativeChat();
         throw error;
@@ -28401,7 +28943,6 @@ function createChatSession({
         if (membershipUpdateStatesRef.current.get(chatId) === state) {
           membershipUpdateStatesRef.current.delete(chatId);
         }
-        releaseMutation();
       }
     })();
     membershipUpdateStatesRef.current.set(chatId, state);
@@ -28524,6 +29065,26 @@ function createChatSession({
     }
     return state.promise;
   };
+  const updateChatAvatar = async (chatId, data) => {
+    assertChatAvatarBytes(data);
+    const chat = requireTransitionChat(chatId);
+    if (chat.lineage !== "group")
+      throw new Error("group chat required");
+    const epochId = chat?.epochState?.manifest?.epochId;
+    if (!epochId)
+      throw new Error("current chat epoch unavailable");
+    const uploadChatMedia = cloud?.chat?.media?.upload;
+    if (typeof uploadChatMedia !== "function")
+      throw new Error("chat media upload unavailable");
+    const cid = makeCid();
+    const file = typeof media?.uploadChatAvatar === "function" ? await media.uploadChatAvatar({ cid, data, epochId, uploadChatMedia }) : await putChatFile(epochId, cid, data, {
+      uploadChatMedia,
+      cacheControl: "private, max-age=31536000, immutable, no-transform"
+    });
+    const avatarRef = makeChatAvatarRef(file);
+    await updateChatSettings2(chatId, { avatarRef });
+    return avatarRef;
+  };
   const adoptCommittedSettingsMessage = ({ chatId, message }) => {
     if (!chatId || !message?.cid)
       return;
@@ -28616,11 +29177,12 @@ function createChatSession({
   const dropChat = (...args) => deleteActions.dropChat(...args);
   const dropUnavailableChat = (...args) => deleteActions.dropUnavailableChat(...args);
   const deleteChat = (...args) => deleteActions.deleteChat(...args);
-  const retireChats = async (affected) => {
+  const purgePeerChats = async (affected) => {
     for (const chat of affected) {
       const retirement = planChatRetirement(chat, chatPK);
       if (retirement.action === CHAT_RETIREMENT_ACTIONS.LEAVE) {
         await leaveOwnedChat(chat, { optimistic: false });
+        await cloud.user.chats.unlink(uid, chat.entryId);
       } else {
         await deleteChat(chat, { cleanup: false });
       }
@@ -28630,7 +29192,7 @@ function createChatSession({
   const retirePeerChat = async (peerChatPK, options = {}) => {
     const allChats = await loadAllChats(cloud, uid, chatPK, chatPrivateKey);
     const affected = allChats.filter((chat) => chat?.members?.some((member) => member.chatPK === peerChatPK));
-    await retireChats(affected);
+    await purgePeerChats(affected);
     await options.onDeliveryRevoked?.();
     return affected.length > 0;
   };
@@ -28639,14 +29201,21 @@ function createChatSession({
       return 0;
     const allChats = await loadAllChats(cloud, uid, chatPK, chatPrivateKey);
     const affected = allChats.filter((chat) => chat?.members?.some((member) => member.chatPK !== chatPK && blockedUids.has(member.uid)));
-    return retireChats(affected);
+    return purgePeerChats(affected);
   };
   const restoreDeletedChat = (...args) => deleteActions.restoreDeletedChat(...args);
   const wasChatDeletedLocally = (...args) => deleteActions.wasChatDeletedLocally(...args);
   const ackDeletedChat = (...args) => deleteActions.ackDeletedChat(...args);
   const markChatReadState = (...args) => seenActions.markChatReadState(...args);
   const markChatRead = (...args) => seenActions.markChatRead(...args);
-  const enterChatActivity = (...args) => liveActions.enterChatActivity(...args);
+  const enterChatActivity = (chatId) => {
+    const reconcileStartedAt = Date.now();
+    chatListOwner.reconcileChatEpoch(chatId).catch((error) => {
+      markError(diag, "chat.epoch.reconcile", reconcileStartedAt, error);
+    });
+    return liveActions.enterChatActivity(chatId);
+  };
+  const flushChatReadFrontier = (chatId) => liveActions.flushChatReadFrontier(chatId);
   const leaveChatActivity = (chatId) => {
     const flush = seenActions.flushChatRead(chatId);
     liveActions.leaveChatActivity(chatId);
@@ -28893,6 +29462,7 @@ function createChatSession({
     listActionsRef: deleteListActionsRef,
     closeMessageBatchRef,
     mutationGate,
+    reconcileEpoch: (chatId) => chatListOwner?.reconcileChatEpoch(chatId),
     diag
   });
   const createActionOwners = () => {
@@ -28972,6 +29542,7 @@ function createChatSession({
       adoptLocalMessageMedia,
       readMessageFile,
       mutationGate,
+      reconcileEpoch: (chatId) => chatListOwner.reconcileChatEpoch(chatId),
       diag
     });
     reactionActions = createChatReaction({
@@ -29052,6 +29623,7 @@ function createChatSession({
     localByChatRef,
     pendingDeleteIdsRef: deleteActions.pendingDeleteIdsRef,
     deletedChatIdsRef: deleteActions.deletedChatIdsRef,
+    removedChatVersionsRef: deleteActions.removedChatVersionsRef,
     keepSelectedDeletedChatIdsRef: deleteActions.keepSelectedDeletedChatIdsRef,
     readCacheRef,
     lastServerChatsRef,
@@ -29067,8 +29639,9 @@ function createChatSession({
     reconcileMessageBatches: (...args) => messageBatchOwner.reconcileChats(...args),
     warmChats: (...args) => messageBatchOwner.warm(...args),
     onTransition: stageCommittedMembershipMessage,
-    onRemoved: (removedChatId) => deleteActions.dropRemovedChat(removedChatId),
-    wasRemoved: (removedChatId) => deleteActions.deletedChatIdsRef.current.has(removedChatId),
+    onRemoved: (removedChatId, epochVersion) => deleteActions.dropRemovedChat(removedChatId, epochVersion),
+    wasRemoved: (removedChatId) => deleteActions.removedChatVersionsRef.current.has(removedChatId),
+    restoreRemovedChat: (chat) => deleteActions.restoreRemovedChat(chat),
     resetExternalChatState,
     mutationGate,
     onMlsKeyPackageConsumed: markMlsKeyPackageConsumed
@@ -29209,12 +29782,13 @@ function createChatSession({
 var DEFAULT_READ_WRITE_INTERVAL_MS, DIAG_KEY_LEN = 12, EMPTY_LOCAL_MESSAGES;
 var init_session3 = __esm(() => {
   init_config();
+  init_files();
+  init_avatar2();
   init_ids();
   init_direct();
   init_create();
   init_membership();
   init_pool();
-  init_owner2();
   init_manifest();
   init_notifications();
   init_state2();
@@ -38088,7 +38662,8 @@ var init_links = __esm(() => {
     ])
   ]);
   storageCorsOrigins = Object.freeze([
-    origins.veyl
+    origins.veyl,
+    origins.veylDevWeb
   ]);
   devStorageCorsOrigins = Object.freeze([
     origins.veylDev,
@@ -38104,12 +38679,19 @@ var init_links = __esm(() => {
 });
 
 // ../../product/passkeylabel.js
+function twoWordLabelAt(index) {
+  if (!Number.isSafeInteger(index) || index < 0) {
+    throw new Error("two-word label index must be a non-negative integer");
+  }
+  const normalized = index % TWO_WORD_LABEL_COUNT;
+  const adjective = adjectives[normalized % adjectives.length];
+  const noun = nouns[Math.floor(normalized / adjectives.length)];
+  return `${adjective} ${noun}`;
+}
 function randomPasskeyLabel() {
-  const adj = adjectives[Math.floor(Math.random() * adjectives.length)];
-  const noun = nouns[Math.floor(Math.random() * nouns.length)];
-  return `${adj} ${noun}`;
+  return twoWordLabelAt(Math.floor(Math.random() * TWO_WORD_LABEL_COUNT));
 }
-var adjectives, nouns;
+var adjectives, nouns, TWO_WORD_LABEL_COUNT;
 var init_passkeylabel = __esm(() => {
   adjectives = [
     "Ancient",
@@ -38176,7 +38758,6 @@ var init_passkeylabel = __esm(() => {
     "Grim",
     "Holy",
     "Infernal",
-    "Ivory",
     "Jade",
     "Light",
     "Midnight",
@@ -38320,6 +38901,7 @@ var init_passkeylabel = __esm(() => {
     "Wizard",
     "Wyvern"
   ];
+  TWO_WORD_LABEL_COUNT = adjectives.length * nouns.length;
 });
 
 // src/auth.js
@@ -38685,6 +39267,7 @@ function simplifyAccountChat(chat, profiles = null) {
     members,
     title: chat.settings?.title || null,
     avatarRef: chat.settings?.avatarRef || null,
+    retention: chat.settings?.retention || null,
     peerChatPK: chat.peerChatPK,
     peerUid: chat.peerUid || directPeer?.uid || null,
     username: directPeer?.username || null,
@@ -38937,6 +39520,8 @@ async function listenAccount(client, options = {}) {
   const includeChats = options.chats !== false;
   const includeTransactions = options.transactions !== false;
   const markRead = options.read !== false;
+  const relayReads = markRead && options.relayReads === true;
+  const readLiveIdleMs = Number.isFinite(Number(options.readLiveIdleMs)) ? Math.max(0, Math.floor(Number(options.readLiveIdleMs))) : 15000;
   const replay = options.replay === true;
   const persistentChatIdleMs = Number.isFinite(Number(options.persistentChatIdleMs)) ? Math.max(0, Math.floor(Number(options.persistentChatIdleMs))) : 0;
   const emit2 = typeof options.onEvent === "function" ? options.onEvent : () => {};
@@ -38947,8 +39532,12 @@ async function listenAccount(client, options = {}) {
   const chatActivityTimers = new Map;
   const subscribedWakeVersions = new Map;
   const idleWakeVersions = new Map;
+  const messageBatchTasks = new Map;
   const pendingChats = new Map;
   const processedWakeVersions = new Map;
+  const readLiveChats = new Set;
+  const readLiveEntering = new Map;
+  const readLiveTimers = new Map;
   const wantedWakeVersions = new Map;
   let activeChatIds = new Set;
   let chatSyncRequested = false;
@@ -38993,6 +39582,44 @@ async function listenAccount(client, options = {}) {
   const account = client.accountSummary();
   const runtime = client.runtime;
   const session = client.session;
+  async function enterReadLive(chatId) {
+    if (!relayReads)
+      return false;
+    if (readLiveChats.has(chatId))
+      return true;
+    const current = readLiveEntering.get(chatId);
+    if (current)
+      return current;
+    const entering = runtime.chat.getSnapshot().enterChatActivity(chatId).then(async (entered) => {
+      if (!entered)
+        return false;
+      if (closed) {
+        await runtime.chat.getSnapshot().leaveChatActivity(chatId);
+        return false;
+      }
+      readLiveChats.add(chatId);
+      return true;
+    }).finally(() => readLiveEntering.delete(chatId));
+    readLiveEntering.set(chatId, entering);
+    return entering;
+  }
+  function releaseReadLiveSoon(chatId) {
+    if (!readLiveChats.has(chatId))
+      return;
+    const current = readLiveTimers.get(chatId);
+    if (current)
+      clearTimeout(current);
+    const timer = setTimeout(() => {
+      if (readLiveTimers.get(chatId) !== timer)
+        return;
+      readLiveTimers.delete(chatId);
+      if (!readLiveChats.delete(chatId))
+        return;
+      runtime.chat.getSnapshot().leaveChatActivity(chatId);
+    }, readLiveIdleMs);
+    timer.unref?.();
+    readLiveTimers.set(chatId, timer);
+  }
   function projectedChat(chat) {
     const peerChatPK = getChatPeerPK(chat);
     const peerByChatPK = runtime.peers.getSnapshot().peerByChatPK;
@@ -39012,13 +39639,15 @@ async function listenAccount(client, options = {}) {
     const sourceMessages = batch?.sourceMessages?.length ? batch.sourceMessages : batch?.messages || [];
     return projectMessages(sourceMessages, session.chatPK, peerChatPK || session.chatPK, chat?.memberChatPKs).map((message) => simplifyAccountMessage(message, chat, session.chatPK, { raw: true }));
   }
-  function applyMessageBatch(chat, batch, emitChanges) {
+  async function applyMessageBatch(chat, batch, emitChanges) {
     if (!batch?.ready)
       return;
     touchChatActivity(chat.id);
     const targetChat = projectedChat(chat);
+    const rawMessages = batch?.sourceMessages?.length ? batch.sourceMessages : batch?.messages || [];
     const messages = projectMessages2(chat, batch);
     const currentKeys = new Set;
+    const messageEvents = [];
     for (const message of messages) {
       const key = messageKey(message);
       if (!key)
@@ -39029,16 +39658,37 @@ async function listenAccount(client, options = {}) {
       seenMessages.set(key, version);
       if (!emitChanges || previous === version || incomingOnly && message.from !== "peer")
         continue;
-      emit2(formatMessageEvent(targetChat, message, { compact: compact2 }));
-    }
-    const latestPeer = [...messages].reverse().find((message) => message.from === "peer");
-    const latestPeerKey = latestPeer ? messageKey(latestPeer) : "";
-    if (markRead && latestPeerKey && readMessages.get(chat.id) !== latestPeerKey) {
-      readMessages.set(chat.id, latestPeerKey);
-      runtime.chat.getSnapshot().markChatReadState(chat.id, latestPeer.raw, {
-        messages: messages.map((message) => message.raw)
-      });
+      messageEvents.push(formatMessageEvent(targetChat, message, { compact: compact2 }));
+    }
+    const latestPeer = [...rawMessages].reverse().find((message) => isPeerMsg(message, session.chatPK));
+    const latestPeerKey = latestPeer ? messageKey({ ...latestPeer, chatId: chat.id }) : "";
+    const latestPeerEvent = latestPeer ? formatMessageEvent(targetChat, simplifyAccountMessage(latestPeer, chat, session.chatPK, { raw: true }), { compact: compact2 }) : null;
+    const readTarget = getLatestReadStateTarget(rawMessages);
+    const readTargetKey = readTarget ? messageKey({ ...readTarget, chatId: chat.id }) : "";
+    const alreadyProcessed = latestPeerEvent && options.isProcessedEvent?.(latestPeerEvent) === true;
+    if (markRead && readTargetKey && !(alreadyProcessed && readTargetKey === latestPeerKey) && readMessages.get(chat.id) !== readTargetKey) {
+      readMessages.set(chat.id, readTargetKey);
+      if (relayReads) {
+        try {
+          await enterReadLive(chat.id);
+          await runtime.chat.getSnapshot().markChatReadState(chat.id, readTarget, { messages: rawMessages });
+          await runtime.chat.getSnapshot().flushChatReadFrontier?.(chat.id);
+        } catch (error) {
+          emit2(event("error", {
+            peer: peerTarget(targetChat),
+            message: error?.message || String(error)
+          }));
+        } finally {
+          releaseReadLiveSoon(chat.id);
+        }
+      } else {
+        runtime.chat.getSnapshot().markChatReadState(chat.id, readTarget, {
+          messages: rawMessages
+        });
+      }
     }
+    for (const messageEvent of messageEvents)
+      emit2(messageEvent);
     const previousForChat = [...seenMessages.keys()].filter((key) => key.startsWith(`${chat.id}:`));
     for (const key of previousForChat) {
       if (currentKeys.has(key))
@@ -39057,6 +39707,21 @@ async function listenAccount(client, options = {}) {
       }
     }
   }
+  function queueMessageBatch(chat, batch, emitChanges) {
+    const previous = messageBatchTasks.get(chat.id) || Promise.resolve();
+    const task = previous.catch(() => {}).then(() => applyMessageBatch(chat, batch, emitChanges));
+    messageBatchTasks.set(chat.id, task);
+    task.then(() => {
+      if (messageBatchTasks.get(chat.id) === task) {
+        messageBatchTasks.delete(chat.id);
+      }
+    }, () => {
+      if (messageBatchTasks.get(chat.id) === task) {
+        messageBatchTasks.delete(chat.id);
+      }
+    });
+    return task;
+  }
   function checkpointBatch(chat, page) {
     const sourceMessages = page?.history?.sourceMessages?.length ? page.history.sourceMessages : page?.batch?.sourceMessages?.length ? page.batch.sourceMessages : page?.batch?.messages || [];
     const batch = {
@@ -39143,13 +39808,15 @@ async function listenAccount(client, options = {}) {
         if (closed || !activeChatIds.has(chat.id) || !page.chat || !transientChats && chatSubscriptions.has(chat.id)) {
           return;
         }
-        applyMessageBatch(chat, page.batch, emitInitial);
+        await queueMessageBatch(chat, page.batch, emitInitial);
         if (transientChats) {
           processedWakeVersions.set(chat.id, wakeVersion);
           return;
         }
         const batches = runtime.chat.getSnapshot().messageBatches;
-        const unsubscribe = batches.subscribeMessageBatch(chat.id, (batch) => applyMessageBatch(chat, batch, ready));
+        const unsubscribe = batches.subscribeMessageBatch(chat.id, (batch) => {
+          queueMessageBatch(chat, batch, ready).catch((error) => emit2(event("error", { peer: peerTarget(targetChat), message: error?.message || String(error) })));
+        });
         chatSubscriptions.set(chat.id, () => {
           unsubscribe();
           page.release?.();
@@ -39283,6 +39950,13 @@ async function listenAccount(client, options = {}) {
     for (const timer of chatActivityTimers.values())
       clearTimeout(timer);
     chatActivityTimers.clear();
+    for (const timer of readLiveTimers.values())
+      clearTimeout(timer);
+    readLiveTimers.clear();
+    await Promise.allSettled(messageBatchTasks.values());
+    await Promise.allSettled(readLiveEntering.values());
+    await Promise.allSettled([...readLiveChats].map((chatId) => runtime.chat.getSnapshot().leaveChatActivity(chatId)));
+    readLiveChats.clear();
     processedWakeVersions.clear();
     wantedWakeVersions.clear();
   }
@@ -39291,6 +39965,7 @@ var DEFAULT_CHAT_COUNT = 20, DEFAULT_MESSAGE_COUNT = 10, DEFAULT_REPLAY_MESSAGE_
 var init_listen = __esm(() => {
   init_actions2();
   init_ids();
+  init_messages();
   init_presentation();
   init_messages3();
 });
@@ -41150,6 +41825,7 @@ function mergeLatestServerPages(primary, secondary) {
   return {
     ...secondary || {},
     ...primary || {},
+    memberStatesByEpoch: mergeChatReceiptCheckpointsByEpoch(secondary?.memberStatesByEpoch, primary?.memberStatesByEpoch),
     expiredKeys: keySet([...primary?.expiredKeys || [], ...secondary?.expiredKeys || []]),
     deletedKeys: keySet([...primary?.deletedKeys || [], ...secondary?.deletedKeys || []])
   };
@@ -41297,6 +41973,7 @@ var init_screen = __esm(() => {
   init_messagekeys();
   init_ids();
   init_state();
+  init_receipt();
   init_time();
   init_control();
   init_window();
@@ -41698,10 +42375,7 @@ var init_resolve = __esm(() => {
 
 // ../../core/chat/messages/serversync.js
 function mergeMemberStates(previous, current) {
-  return new Map([
-    ...previous instanceof Map ? previous : [],
-    ...current instanceof Map ? current : []
-  ]);
+  return mergeChatReceiptCheckpointsByEpoch(previous, current);
 }
 function isEpochBatchCutover(latestServerPage, msgBatch) {
   return !!(latestServerPage?.epochId && msgBatch?.epochId && latestServerPage.epochId !== msgBatch.epochId);
@@ -41925,6 +42599,7 @@ var init_serversync = __esm(() => {
   init_messagekeys();
   init_messages();
   init_state();
+  init_receipt();
   init_resolve();
   init_history();
   init_window();
@@ -42353,6 +43028,7 @@ function conversationStateSignature(state) {
     cacheMessageListSignature(state.latestMessages),
     cacheKeySignature(state.latestServerPage?.expiredKeys),
     cacheKeySignature(state.latestServerPage?.deletedKeys),
+    cachedReceiptCheckpointSignature(state.latestServerPage?.memberStatesByEpoch),
     reactionControlCacheSignature(state)
   ].join(`
 `);
@@ -44192,6 +44868,7 @@ function deriveMessageRouteProjection({
     routeActive: routeRetained
   }));
   const { rawMessages, messages, visibleMessages } = routeMessages;
+  const memberStatesByEpoch = activeState.latestServerPage?.memberStatesByEpoch || EMPTY_MEMBER_STATES_BY_EPOCH;
   return {
     activeExists: activeState.exists,
     activeHasOlder: activeState.hasOlder,
@@ -44200,7 +44877,7 @@ function deriveMessageRouteProjection({
     activeLatestMessages: activeState.latestMessages,
     activeLatestServerPage: activeState.latestServerPage,
     activeReady: activeState.ready,
-    memberStatesByEpoch: activeState.latestServerPage?.memberStatesByEpoch || new Map,
+    memberStatesByEpoch,
     leaveState: {
       chatId,
       exists: activeState.exists,
@@ -44211,7 +44888,7 @@ function deriveMessageRouteProjection({
       selfChatPublicKey,
       peerChatPublicKey,
       memberChatPKs,
-      memberStatesByEpoch: activeState.latestServerPage?.memberStatesByEpoch || new Map,
+      memberStatesByEpoch,
       conversationKeys,
       routeMemory,
       keepKeys: getRouteKeepKeys(refs.visibleMessageKeys.current, refs.heldMessages.current),
@@ -44317,7 +44994,7 @@ function recordRouteProjectionDiagnostics({
     markDiag(diag, "chat.messages.route.visible", visibleData);
   }
 }
-var PASSIVE_OLDER_OVERFLOW_PAGES = 3, ROUTE_VISIBLE_DETAIL_SCAN_LIMIT = 160, DIAG_KEY_LEN2 = 12;
+var PASSIVE_OLDER_OVERFLOW_PAGES = 3, ROUTE_VISIBLE_DETAIL_SCAN_LIMIT = 160, DIAG_KEY_LEN2 = 12, EMPTY_MEMBER_STATES_BY_EPOCH;
 var init_routeprojection = __esm(() => {
   init_messagekeys();
   init_state();
@@ -44325,6 +45002,7 @@ var init_routeprojection = __esm(() => {
   init_history();
   init_payloadlog();
   init_window();
+  EMPTY_MEMBER_STATES_BY_EPOCH = new Map;
 });
 
 // ../../core/chat/messages/expirycleanup.js
@@ -45350,7 +46028,7 @@ function createMessageRouteSession({
       return;
     const localTarget = getLatestLocalReadTarget(viewedMessages, current.selfChatPublicKey);
     const localTargetKey = messageKey2(localTarget);
-    const target = getLatestReadStateTarget(viewedMessages);
+    const target = getLatestReadStateTarget(current.rawMessages?.length ? current.rawMessages : viewedMessages);
     const targetKey = messageKey2(target);
     const localChanged = !!localTargetKey && localTargetKey !== refs.lastSelfReadTarget.current;
     const stateChanged = !!targetKey && targetKey !== refs.lastSharedReadTarget.current;
@@ -46707,6 +47385,9 @@ function positiveLimit2(value, fallback = 30) {
   const limit = Math.floor(Number(value) || fallback);
   return Math.max(1, Math.min(limit, 500));
 }
+function messageIsPermanent(message) {
+  return message?.permanent === true || Object.prototype.hasOwnProperty.call(message || {}, "ttl") && message.ttl == null;
+}
 function waitFor2(owner, predicate, timeoutMs = DEFAULT_TIMEOUT_MS4) {
   const current = owner.getSnapshot();
   if (predicate(current))
@@ -46874,7 +47555,7 @@ function createRuntimeChatActions({
     const profiles2 = await resolveTargetProfiles(peers, session, runtime);
     const settings = {
       title: cleanText(options.title) || null,
-      avatarRef: cleanText(options.avatarRef) || null,
+      avatarRef: null,
       retention: cleanText(options.retention) || "seen"
     };
     const initialText = typeof options.initialMessage === "string" ? options.initialMessage : "";
@@ -46904,11 +47585,25 @@ function createRuntimeChatActions({
     return { left: result?.left === true || result?.deleted === true, chatId: chat.id };
   }
   async function updateSettings(chatId, settings = {}) {
+    if (Object.prototype.hasOwnProperty.call(settings || {}, "avatarRef")) {
+      throw new Error("use chat.updateAvatar for chat pictures");
+    }
     const { runtime, chat } = await chatForId(chatId);
     await runtime.chat.getSnapshot().updateChatSettings(chat.id, settings);
     const next = await chatForId(chat.id);
     return summarizeChat(runtime, next.chat);
   }
+  async function updateAvatar(chatId, data = null) {
+    const { runtime, chat } = await chatForId(chatId);
+    const snapshot2 = runtime.chat.getSnapshot();
+    if (data == null) {
+      await snapshot2.updateChatSettings(chat.id, { avatarRef: null });
+    } else {
+      await snapshot2.updateChatAvatar(chat.id, data);
+    }
+    const next = await chatForId(chat.id);
+    return summarizeChat(runtime, next.chat);
+  }
   async function enterById(chatId, options = {}) {
     const session = await getSession();
     const { runtime, chat, profile } = await chatForId(chatId);
@@ -46935,6 +47630,31 @@ function createRuntimeChatActions({
     const route = enteredChats.get(id);
     return { exited: route?.leave() === true, chatId: id || null };
   }
+  async function enterLive(chatId) {
+    const { runtime, chat } = await chatForId(chatId);
+    const entered2 = await runtime.chat.getSnapshot().enterChatActivity(chat.id);
+    return { entered: entered2 === true, chatId: chat.id };
+  }
+  async function leaveLive(chatId) {
+    const id = cleanText(chatId).toLowerCase();
+    if (!/^[0-9a-f]{64}$/u.test(id))
+      throw new Error("chat id required");
+    const runtime = await getRuntime();
+    await runtime.chat.getSnapshot().leaveChatActivity(id);
+    return { left: true, chatId: id };
+  }
+  async function markTyping(chatId, typing = true, compositionId = "") {
+    const { runtime, chat } = await chatForId(chatId);
+    const nextTyping = typing === true;
+    const nextCompositionId = cleanText(compositionId).toLowerCase() || (nextTyping ? makeChatCompositionId() : "");
+    const marked = runtime.chat.getSnapshot().markChatTyping(chat.id, nextTyping, nextCompositionId);
+    return {
+      marked: marked === true,
+      typing: nextTyping,
+      compositionId: nextCompositionId,
+      chatId: chat.id
+    };
+  }
   async function readById(chatId, options = {}) {
     const window2 = await messageWindowById(chatId, options);
     try {
@@ -47079,6 +47799,13 @@ function createRuntimeChatActions({
   }
   async function saveInChat(chatId, messageId, saved = true, options = {}) {
     const target = await messageForChat(chatId, messageId, options);
+    if (saved === messageIsPermanent(target.message)) {
+      return {
+        chat: summarizeChat(target.runtime, target.chat),
+        saved,
+        updated: 0
+      };
+    }
     const result = saved ? await target.runtime.chat.getSnapshot().makeMessagePermanent(target.chat.id, target.message) : await target.runtime.chat.getSnapshot().makeMessageTemporary(target.chat.id, target.message);
     if (!result?.updated)
       throw new Error("message no longer available");
@@ -47573,10 +48300,14 @@ function createRuntimeChatActions({
     addMembers,
     kickMember,
     leaveMembership,
+    updateAvatar,
     updateSettings,
     readById,
     enterById,
     exitById,
+    enterLive,
+    leaveLive,
+    markTyping,
     sendToChat,
     sendAttachmentToChat,
     readAttachmentInChat,
@@ -47996,6 +48727,7 @@ var DEFAULT_TIMEOUT_MS4 = 15000, HISTORY_LOAD_ATTEMPTS = 4, messageWindowSequenc
 var init_runtime_actions = __esm(() => {
   init_messages();
   init_ids();
+  init_live();
   init_state();
   init_actions2();
   init_fees();
@@ -48013,7 +48745,7 @@ var package_default;
 var init_package2 = __esm(() => {
   package_default = {
     name: "veyl",
-    version: "0.59.1",
+    version: "0.61.0",
     private: true,
     license: "UNLICENSED",
     workspaces: {
@@ -48342,10 +49074,14 @@ class AccountRuntime {
       addMembers: (chatId, peers) => this.runtimeChat.addMembers(chatId, peers),
       kickMember: (chatId, memberChatPK) => this.runtimeChat.kickMember(chatId, memberChatPK),
       leaveMembership: (chatId) => this.runtimeChat.leaveMembership(chatId),
+      updateAvatar: (chatId, data) => this.runtimeChat.updateAvatar(chatId, data),
       updateSettings: (chatId, payload) => this.runtimeChat.updateSettings(chatId, payload),
       readById: (chatId, payload) => this.runtimeChat.readById(chatId, payload),
       enterById: (chatId, payload) => this.runtimeChat.enterById(chatId, payload),
       exitById: (chatId) => this.runtimeChat.exitById(chatId),
+      enterLive: (chatId) => this.runtimeChat.enterLive(chatId),
+      leaveLive: (chatId) => this.runtimeChat.leaveLive(chatId),
+      markTyping: (chatId, typing, compositionId) => this.runtimeChat.markTyping(chatId, typing, compositionId),
       sendTo: (chatId, message, payload) => this.runtimeChat.sendToChat(chatId, message, payload),
       replyIn: (chatId, messageId, message, payload) => this.runtimeChat.replyInChat(chatId, messageId, message, payload),
       reactIn: (chatId, messageId, emoji, payload) => this.runtimeChat.reactInChat(chatId, messageId, emoji, payload),
@@ -48807,7 +49543,9 @@ class AccountRuntime {
     }
     const vault = await this.cloud.user.vault.read(profile.uid);
     if (!vault) {
-      throw new Error("vault not found");
+      throw Object.assign(new Error("vault not found"), {
+        code: "not-found"
+      });
     }
     return {
       mnemonic: await this.ports.vaultCrypto.decryptWalletMnemonic(vault, vaultSecret),
@@ -48825,7 +49563,9 @@ class AccountRuntime {
     }
     const vault = await this.cloud.user.vault.read(profile.uid);
     if (!vault) {
-      throw new Error("vault not found");
+      throw Object.assign(new Error("vault not found"), {
+        code: "not-found"
+      });
     }
     const session = await this.bootSession(vault, vaultSecret, profile);
     const next = await this.saveProfile({
@@ -181896,7 +182636,7 @@ function firebaseFunctionTarget(environment, name7) {
   if (!/^[A-Za-z][A-Za-z0-9]*$/u.test(target)) {
     throw new Error("Invalid Firebase function target");
   }
-  return `${resolved.name}-${target}`;
+  return resolved.name === "dev" ? `dev-${target}` : target;
 }
 var firebaseConfig, firebaseEnvironments, defaultFirebaseEnvironment;
 var init_config3 = __esm(() => {
@@ -182865,14 +183605,14 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
     const { entryId, expectedEpochId, stateCapability, cleanup = true } = options2 || {};
     if (!chatId || !expectedEpochId || !stateCapability)
       throw new Error("current chat state required");
-    await callFunction("deleteChat", {
+    const result = await callFunction("deleteChat", {
       chatId,
       expectedEpochId,
       stateCapabilityWitness: stateCapabilityWitness(stateCapability),
       ...entryId ? { entryId } : {},
       cleanup: cleanup !== false
     });
-    return true;
+    return { newlyDeleted: result?.newlyDeleted === true };
   }
   function cleanOpaqueState(value) {
     const chat = value?.chat || value || {};
@@ -183014,10 +183754,10 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
       ]).catch(() => []);
       const [epochSnap, settingsSnap, packageSnap, ownerSnap, ownerMlsSnap] = snapshots;
       const outboxSnaps = snapshots.slice(5);
-      const currentEpoch = epochSnap?.data?.() || {};
+      const currentEpoch2 = epochSnap?.data?.() || {};
       const currentSettings = settingsSnap?.data?.() || {};
       const currentPackage = packageSnap?.data?.() || {};
-      const matches = epochSnap?.exists?.() && settingsSnap?.exists?.() && packageSnap?.exists?.() && currentEpoch.protocol === CHAT_PROTOCOL_VERSION && currentEpoch.chatId === chatId && currentEpoch.epochVersion === 1 && currentEpoch.settingsId === payload.settings.id && currentEpoch.mlsPackageId === payload.mlsPackage.head.packageId && currentEpoch.mlsPackageDigest === payload.mlsPackage.digest && currentEpoch.status === "open" && sameChatSettingsHead(currentSettings.head, settings.data.head) && sameCloudBytes(currentSettings.body, settings.data.body) && currentPackage?.head?.packageId === payload.mlsPackage.head.packageId && currentPackage?.digest === payload.mlsPackage.digest && ownerSnap?.exists?.() && sameCloudBytes(ownerSnap.data()?.body, ownerEntry.data.body) && ownerMlsSnap?.exists?.() && sameCloudBytes(ownerMlsSnap.data()?.body, ownerMlsState.data.body) && membershipOutbox.every((outbox, index) => {
+      const matches = epochSnap?.exists?.() && settingsSnap?.exists?.() && packageSnap?.exists?.() && currentEpoch2.protocol === CHAT_PROTOCOL_VERSION && currentEpoch2.chatId === chatId && currentEpoch2.epochVersion === 1 && currentEpoch2.settingsId === payload.settings.id && currentEpoch2.mlsPackageId === payload.mlsPackage.head.packageId && currentEpoch2.mlsPackageDigest === payload.mlsPackage.digest && currentEpoch2.status === "open" && sameChatSettingsHead(currentSettings.head, settings.data.head) && sameCloudBytes(currentSettings.body, settings.data.body) && currentPackage?.head?.packageId === payload.mlsPackage.head.packageId && currentPackage?.digest === payload.mlsPackage.digest && ownerSnap?.exists?.() && sameCloudBytes(ownerSnap.data()?.body, ownerEntry.data.body) && ownerMlsSnap?.exists?.() && sameCloudBytes(ownerMlsSnap.data()?.body, ownerMlsState.data.body) && membershipOutbox.every((outbox, index) => {
         const current = outboxSnaps[index]?.data?.() || {};
         return outboxSnaps[index]?.exists?.() && sameCloudBytes(current.body, outbox.data.body) && timestampMs(current.ttl, null) === timestampMs(outbox.data.ttl, null);
       });
@@ -183929,6 +184669,15 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
     await callFunction("unlinkChatOwner", { entryId });
     return true;
   }
+  async function unlinkDeletedUserChat(uid, entryId, chatId) {
+    requireUid(uid);
+    if (!entryId)
+      throw new Error("chat entry id required");
+    if (!chatId)
+      throw new Error("chat id required");
+    await callFunction("unlinkChatOwner", { entryId, deletedChatId: chatId });
+    return true;
+  }
   function userChatEpochCollection(uid, entryId) {
     requireUid(uid);
     if (!entryId)
@@ -184232,6 +184981,7 @@ function createFirebaseCloud({ db, auth: auth2, getAuth: getAuth2, functions: fu
         mutate: mutateUserChat,
         delete: deleteUserChat,
         unlink: unlinkUserChat,
+        unlinkDeleted: unlinkDeletedUserChat,
         membershipOutbox: {
           list: listUserChatMembershipOutbox,
           delete: deleteUserChatMembershipOutbox
@@ -186600,6 +187350,7 @@ class FleetOwner {
     this.manifest = options2.manifest;
     this.seed = options2.seed;
     this.homeDir = options2.homeDir || defaultHomeDir();
+    this.profileHomeDir = options2.profileHomeDir || this.homeDir;
     this.openClient = options2.openClient || createAccountRuntime;
     this.policies = [...options2.policies || []];
     this.policyLoader = options2.policyLoader || null;
@@ -186646,7 +187397,7 @@ class FleetOwner {
     try {
       return {
         ...await this.baseClientOptions(profile),
-        homeDir: this.homeDir,
+        homeDir: this.profileHomeDir,
         activate: false,
         credential: material.credential,
         vaultKey: material.vaultSecret,
@@ -186782,6 +187533,36 @@ class FleetOwner {
       await this.lock.release();
     }
   }
+  profileStore(profile) {
+    return new ProfileStore({
+      dir: this.profileHomeDir,
+      profile,
+      activate: false
+    });
+  }
+  async hasLocalProfile(profile) {
+    const name7 = cleanProfileName(profile, "");
+    if (!name7)
+      return false;
+    return Boolean(await this.profileStore(name7).load(name7));
+  }
+  async ensureLocalProfile(record, credential) {
+    const store = this.profileStore(record.profile);
+    if (await store.load(record.profile))
+      return store;
+    await store.save({
+      profile: record.profile,
+      username: record.username,
+      network: record.network,
+      credentialId: credential.credentialId,
+      publicKeyPem: credential.publicKeyPem,
+      privateKeyPem: null,
+      auth: "machine",
+      hasVault: false,
+      createdAt: Date.now()
+    });
+    return store;
+  }
   provision(input = {}) {
     return this.mutate(async () => {
       if (this.fleet) {
@@ -186816,32 +187597,75 @@ class FleetOwner {
       });
     });
   }
-  async finishProvision(record, options2) {
-    const material = deriveFleetAccount(this.seed, record.accountIndex);
-    const store = new ProfileStore({
-      dir: this.homeDir,
-      profile: record.profile,
-      activate: false
+  prepare(profile) {
+    return this.mutate(async () => {
+      if (this.fleet) {
+        throw new Error("stop the fleet owner before preparing an account");
+      }
+      return this.withStoppedOwnerLock(async () => {
+        const record = this.slot(profile);
+        if (!record)
+          throw new Error("fleet profile not found");
+        if (record.state !== "ready") {
+          throw new Error("fleet profile must be ready before preparation");
+        }
+        return this.finishProvision(record, {
+          create: false,
+          recoverMissing: false,
+          saveManifest: false,
+          runHook: false
+        });
+      });
     });
-    const existing = await store.load(record.profile);
-    if (!existing) {
-      await store.save({
-        profile: record.profile,
-        username: record.username,
-        network: record.network,
-        credentialId: material.credential.credentialId,
-        publicKeyPem: material.credential.publicKeyPem,
-        privateKeyPem: null,
-        auth: "machine",
-        hasVault: false,
-        createdAt: Date.now()
+  }
+  retire(profile, options2 = {}) {
+    return this.mutate(async () => {
+      if (options2.confirm !== true) {
+        throw new Error("fleet account retirement requires confirm: true");
+      }
+      if (this.fleet) {
+        throw new Error("stop the fleet owner before retiring an account");
+      }
+      return this.withStoppedOwnerLock(async () => {
+        const record = this.slot(profile);
+        if (!record)
+          throw new Error("fleet profile not found");
+        if (record.state !== "ready") {
+          throw new Error("fleet profile must be ready before retirement");
+        }
+        const clientOptions = await this.derivedClientOptions(record);
+        await this.ensureLocalProfile(record, clientOptions.credential);
+        const client2 = await this.openClient({
+          ...clientOptions,
+          profile: record.profile,
+          network: record.network
+        }, record);
+        try {
+          await client2.account.login({
+            credential: clientOptions.credential
+          });
+          await client2.ensureUnlocked();
+          const result = await client2.account.delete({ confirm: true });
+          await this.saveProfiles(this.manifest.profiles.filter((item) => item.profile !== record.profile), this.manifest.nextAccountIndex);
+          return {
+            profile: record.profile,
+            username: record.username,
+            deleted: result?.deleted !== false
+          };
+        } finally {
+          await client2.close();
+        }
       });
-    }
+    });
+  }
+  async finishProvision(record, options2) {
+    const material = deriveFleetAccount(this.seed, record.accountIndex);
+    await this.ensureLocalProfile(record, material.credential);
     const client2 = await this.openClient({
       ...await this.baseClientOptions(record),
       profile: record.profile,
       network: record.network,
-      homeDir: this.homeDir,
+      homeDir: this.profileHomeDir,
       activate: false,
       credential: material.credential,
       vaultKey: material.vaultSecret,
@@ -186867,6 +187691,8 @@ class FleetOwner {
           } catch (error) {
             if (error?.code !== "not-found")
               throw error;
+            if (options2.recoverMissing === false)
+              throw error;
             await client2.account.create({
               username: record.username,
               network: record.network,
@@ -186881,23 +187707,38 @@ class FleetOwner {
           credential: material.credential
         });
       }
-      if (account.hasVault !== true) {
+      try {
+        await client2.vault.unlock({
+          key: material.vaultSecret,
+          saveKey: false
+        });
+      } catch (error) {
+        if (error?.code !== "not-found")
+          throw error;
+        if (options2.recoverMissing === false)
+          throw error;
         await client2.vault.create({
           key: material.vaultSecret,
           masterSeed: material.masterSeed,
           registry: material.registry,
           saveKey: false
         });
-        account = await client2.account.me();
-      } else {
-        await client2.ensureUnlocked();
-        account = await client2.account.me();
       }
+      account = await client2.account.me();
       const ready2 = Object.freeze({
         ...record,
         state: "ready"
       });
-      await this.saveProfiles(this.manifest.profiles.map((item) => item.profile === ready2.profile ? ready2 : item), this.manifest.nextAccountIndex);
+      if (options2.runHook !== false && typeof this.options.onProvisioned === "function") {
+        await this.options.onProvisioned({
+          account,
+          client: client2,
+          profile: ready2
+        });
+      }
+      if (options2.saveManifest !== false) {
+        await this.saveProfiles(this.manifest.profiles.map((item) => item.profile === ready2.profile ? ready2 : item), this.manifest.nextAccountIndex);
+      }
       return {
         account,
         accountIndex: ready2.accountIndex,
@@ -187571,7 +188412,23 @@ var CLI_COMMANDS = Object.freeze([
   command({ name: "chat_add_members", group: "chat", apiName: "addMembers", description: "Add established peers in one membership epoch.", properties: { chatId: stringProp, peers: stringArrayProp }, required: ["chatId", "peers"], usage: "chat add-members chat-id @one,@two", cliInput: chatMembersInput, access: "write", invoke: (client2, input) => client2.chat.addMembers(input.chatId, peerList(input.peers)) }),
   command({ name: "chat_kick_member", group: "chat", apiName: "kickMember", description: "Kick one member by chat public key.", properties: { chatId: stringProp, memberChatPK: stringProp }, required: ["chatId", "memberChatPK"], usage: "chat kick-member chat-id member-chat-pk", cliInput: (args, context) => ({ ...context.commandOptions, chatId: args[0], memberChatPK: args[1] }), access: "destructive", invoke: (client2, input) => client2.chat.kickMember(input.chatId, input.memberChatPK) }),
   command({ name: "chat_leave_membership", group: "chat", apiName: "leaveMembership", description: "Leave a chat without deleting it for the remaining members.", properties: { chatId: stringProp }, required: ["chatId"], usage: "chat leave-membership chat-id", cliInput: chatIdInput, access: "destructive", invoke: (client2, input) => client2.chat.leaveMembership(input.chatId) }),
-  command({ name: "chat_update_settings", group: "chat", apiName: "updateSettings", description: "Update the signed encrypted chat title, avatar reference, or retention settings.", properties: { chatId: stringProp, settings: objectProp }, required: ["chatId", "settings"], usage: "chat update-settings chat-id json", cliInput: chatSettingsInput, access: "write", invoke: (client2, input) => client2.chat.updateSettings(input.chatId, input.settings) }),
+  command({ name: "chat_update_settings", group: "chat", apiName: "updateSettings", description: "Update the signed encrypted chat title or retention settings.", properties: { chatId: stringProp, settings: objectProp }, required: ["chatId", "settings"], usage: "chat update-settings chat-id json", cliInput: chatSettingsInput, access: "write", invoke: (client2, input) => client2.chat.updateSettings(input.chatId, input.settings) }),
+  command({
+    name: "chat_avatar_set",
+    group: "chat",
+    apiName: "setAvatar",
+    clientMethods: ["updateAvatar"],
+    description: "Encrypt and set a prepared WebP group picture.",
+    properties: { chatId: stringProp, dataBase64: stringProp },
+    required: ["chatId", "dataBase64"],
+    usage: "chat avatar-set chat-id <webp-path>",
+    cliInput: (args, context) => ({ ...context.commandOptions, chatId: args[0], path: args[1] }),
+    access: "write",
+    invoke: (client2, input) => client2.chat.updateAvatar(input.chatId, assertWebp(avatarBytes(input))),
+    invokeCli: async (client2, input) => client2.chat.updateAvatar(input.chatId, assertWebp(new Uint8Array(await readFile10(resolve8(String(input.path || "")))))),
+    prepareDispatch: dispatchAvatar
+  }),
+  command({ name: "chat_avatar_delete", group: "chat", apiName: "deleteAvatar", clientMethods: ["updateAvatar"], description: "Restore the automatic member-stack group picture.", properties: { chatId: stringProp }, required: ["chatId"], usage: "chat avatar-delete chat-id", cliInput: chatIdInput, access: "write", invoke: (client2, input) => client2.chat.updateAvatar(input.chatId, null) }),
   command({ name: "chat_messages_by_id", group: "chat", apiName: "readById", description: "Read a chat transcript by stable logical id.", properties: { chatId: stringProp, count: numberProp, readPolicy: stringProp }, required: ["chatId"], usage: "chat messages-by-id chat-id", cliInput: chatIdInput, access: "write", invoke: (client2, input) => client2.chat.readById(input.chatId, input) }),
   command({
     name: "chat_enter_by_id",