@glyphteck/veyl 0.59.0 → 0.60.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 {
@@ -11011,369 +11412,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(() => {
@@ -12321,7 +12359,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 +12374,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 +12397,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 +12405,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));
@@ -12735,6 +12770,7 @@ var init_control = __esm(() => {
   init_messagekeys();
   init_ttl();
   init_actions();
+  init_config();
   init_avatar2();
   init_files2();
   init_text();
@@ -13241,13 +13277,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);
 }
@@ -15926,7 +15961,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);
@@ -18273,11 +18308,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 +18424,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 +18540,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 +18618,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,
@@ -20040,7 +20142,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 +20473,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 +20833,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;
@@ -24972,7 +25142,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 +25161,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")
@@ -25262,7 +25451,21 @@ async function processOpenedPing(cloud, uid, identity, ping, openedProfile, hint
     return "stale";
   }
   if (entry && payload.epochVersion > entry.current.manifest.epochVersion) {
-    const advanced = await advanceEntryToEpoch(cloud, uid, identity, entry, payload.epochVersion, options);
+    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";
@@ -25318,6 +25521,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";
     }
   }
@@ -25426,8 +25634,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 +25650,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 +25679,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) {
@@ -25484,9 +25702,10 @@ async function applyEpochTransitionAction(cloud, uid, identityValue, entry, acti
       if (leaveProposalId) {
         options.leaveProposalObservedAt?.delete(`${parent.chatId}:${leaveProposalId}`);
       }
-      options.onRemoved?.(parent.chatId);
+      options.onRemoved?.(parent.chatId, confirmed.nextEpochVersion);
       return { removed: true, chatId: parent.chatId };
     }
+    openStage = "mls-package-open";
     const opened = await openChatMlsEpochPackage(processed, packageRecord, {
       chatId: parent.chatId,
       senderSigningPK: sender.chatSigningPK,
@@ -25501,8 +25720,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 +25813,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;
@@ -25725,6 +25985,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 +26068,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 +26143,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
@@ -26250,6 +26525,7 @@ function createChatList({
   localByChatRef,
   pendingDeleteIdsRef,
   deletedChatIdsRef,
+  removedChatVersionsRef,
   keepSelectedDeletedChatIdsRef,
   readCacheRef,
   lastServerChatsRef,
@@ -26267,6 +26543,7 @@ function createChatList({
   onTransition,
   onRemoved,
   wasRemoved,
+  restoreRemovedChat,
   resetExternalChatState,
   mutationGate,
   onMlsKeyPackageConsumed
@@ -26295,6 +26572,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 +26582,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 +26797,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 +26829,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 +27059,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 +27172,7 @@ function createChatList({
       blockedUids: blockedUidSet,
       localCache,
       diag,
+      optimisticChats: inboxOverlayChats,
       getCurrentChat: (chatId) => lastServerChatsRef.current.find((chatItem) => chatItem?.id === chatId) || null,
       mutationGate,
       onMlsKeyPackageConsumed
@@ -26957,12 +27351,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 +27382,7 @@ function createChatList({
       localByChatRef,
       pendingDeleteIdsRef,
       deletedChatIdsRef,
+      removedChatVersionsRef,
       keepSelectedDeletedChatIdsRef,
       readCacheRef,
       lastServerChatsRef,
@@ -27001,6 +27400,7 @@ function createChatList({
       onTransition,
       onRemoved,
       wasRemoved,
+      restoreRemovedChat,
       resetExternalChatState,
       mutationGate,
       onMlsKeyPackageConsumed
@@ -27044,6 +27444,8 @@ function createChatList({
       previewTimerRef.current = null;
     }
     flushChatCacheWrite();
+    epochReconciliations.clear();
+    inboxOverlayChats.clear();
     subscribers.clear();
   };
   const subscribe = (subscriber) => {
@@ -27069,6 +27471,7 @@ function createChatList({
     getChatPreviewKey: getChatPreviewKey2,
     getChatRetention,
     getChatEntry,
+    reconcileChatEpoch,
     sendOptionsForPeer,
     hasChat
   };
@@ -27079,6 +27482,7 @@ var init_listsession = __esm(() => {
   init_localdata();
   init_chats();
   init_list();
+  init_inbox2();
   init_ttl();
   init_ids();
   init_time();
@@ -27283,7 +27687,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 +27725,7 @@ function createChatSession({
       kickChatMember,
       leaveChat,
       updateChatSettings: updateChatSettings2,
+      updateChatAvatar,
       dropChat,
       dropUnavailableChat,
       deleteChat,
@@ -27780,51 +28184,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 +28210,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();
@@ -28300,10 +28663,10 @@ function createChatSession({
         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 +28728,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 +28784,6 @@ function createChatSession({
         if (membershipUpdateStatesRef.current.get(chatId) === state) {
           membershipUpdateStatesRef.current.delete(chatId);
         }
-        releaseMutation();
       }
     })();
     membershipUpdateStatesRef.current.set(chatId, state);
@@ -28524,6 +28906,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;
@@ -28646,7 +29048,13 @@ function createChatSession({
   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 leaveChatActivity = (chatId) => {
     const flush = seenActions.flushChatRead(chatId);
     liveActions.leaveChatActivity(chatId);
@@ -28893,6 +29301,7 @@ function createChatSession({
     listActionsRef: deleteListActionsRef,
     closeMessageBatchRef,
     mutationGate,
+    reconcileEpoch: (chatId) => chatListOwner?.reconcileChatEpoch(chatId),
     diag
   });
   const createActionOwners = () => {
@@ -28972,6 +29381,7 @@ function createChatSession({
       adoptLocalMessageMedia,
       readMessageFile,
       mutationGate,
+      reconcileEpoch: (chatId) => chatListOwner.reconcileChatEpoch(chatId),
       diag
     });
     reactionActions = createChatReaction({
@@ -29052,6 +29462,7 @@ function createChatSession({
     localByChatRef,
     pendingDeleteIdsRef: deleteActions.pendingDeleteIdsRef,
     deletedChatIdsRef: deleteActions.deletedChatIdsRef,
+    removedChatVersionsRef: deleteActions.removedChatVersionsRef,
     keepSelectedDeletedChatIdsRef: deleteActions.keepSelectedDeletedChatIdsRef,
     readCacheRef,
     lastServerChatsRef,
@@ -29067,8 +29478,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,6 +29621,8 @@ 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();
@@ -38088,7 +38502,8 @@ var init_links = __esm(() => {
     ])
   ]);
   storageCorsOrigins = Object.freeze([
-    origins.veyl
+    origins.veyl,
+    origins.veylDevWeb
   ]);
   devStorageCorsOrigins = Object.freeze([
     origins.veylDev,
@@ -38104,12 +38519,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 +38598,6 @@ var init_passkeylabel = __esm(() => {
     "Grim",
     "Holy",
     "Infernal",
-    "Ivory",
     "Jade",
     "Light",
     "Midnight",
@@ -38320,6 +38741,7 @@ var init_passkeylabel = __esm(() => {
     "Wizard",
     "Wyvern"
   ];
+  TWO_WORD_LABEL_COUNT = adjectives.length * nouns.length;
 });
 
 // src/auth.js
@@ -38685,6 +39107,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,
@@ -44192,6 +44615,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 +44624,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 +44635,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 +44741,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 +44749,7 @@ var init_routeprojection = __esm(() => {
   init_history();
   init_payloadlog();
   init_window();
+  EMPTY_MEMBER_STATES_BY_EPOCH = new Map;
 });
 
 // ../../core/chat/messages/expirycleanup.js
@@ -46707,6 +47132,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 +47302,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 +47332,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);
@@ -47079,6 +47521,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,6 +48022,7 @@ function createRuntimeChatActions({
     addMembers,
     kickMember,
     leaveMembership,
+    updateAvatar,
     updateSettings,
     readById,
     enterById,
@@ -48013,7 +48463,7 @@ var package_default;
 var init_package2 = __esm(() => {
   package_default = {
     name: "veyl",
-    version: "0.59.0",
+    version: "0.60.0",
     private: true,
     license: "UNLICENSED",
     workspaces: {
@@ -48342,6 +48792,7 @@ 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),
@@ -48807,7 +49258,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 +49278,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 +182351,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 +183320,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 +183469,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 +184384,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 +184696,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 +187065,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 +187112,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 +187248,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 +187312,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 +187406,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 +187422,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 +188127,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",