stream-chat 10.0.0-rc.12 → 10.0.0-rc.13

package/dist/cjs/index.browser.js

@@ -167,7 +167,6 @@ __export(src_exports, {
   createPollComposerStateMiddleware: () => createPollComposerStateMiddleware,
   createPostUploadAttachmentEnrichmentMiddleware: () => createPostUploadAttachmentEnrichmentMiddleware,
   createPriorityOwnershipResolver: () => createPriorityOwnershipResolver,
-  createSendWithPendingUploadsAttachmentsMiddleware: () => createSendWithPendingUploadsAttachmentsMiddleware,
   createSharedLocationCompositionMiddleware: () => createSharedLocationCompositionMiddleware,
   createTextComposerCompositionMiddleware: () => createTextComposerCompositionMiddleware,
   createTextComposerPreValidationMiddleware: () => createTextComposerPreValidationMiddleware,
@@ -186,6 +185,7 @@ __export(src_exports, {
   formatMessage: () => formatMessage,
   generateFileName: () => generateFileName,
   getAllowedMentionTypesFromCapabilities: () => getAllowedMentionTypesFromCapabilities,
+  getAttachmentPreviewUrl: () => getAttachmentPreviewUrl,
   getAttachmentTypeFromMimeType: () => getAttachmentTypeFromMimeType,
   getCommandByName: () => getCommandByName,
   getCompleteCommandInString: () => getCompleteCommandInString,
@@ -200,6 +200,7 @@ __export(src_exports, {
   insertItemWithTrigger: () => insertItemWithTrigger,
   isAudioAttachment: () => isAudioAttachment,
   isBlobButNotFile: () => isBlobButNotFile,
+  isFailedUpload: () => isFailedUpload,
   isFile: () => isFile,
   isFileAttachment: () => isFileAttachment,
   isFileList: () => isFileList,
@@ -225,6 +226,7 @@ __export(src_exports, {
   isSharedLocationResponseData: () => isSharedLocationResponseData,
   isTargetedOptionTextUpdate: () => isTargetedOptionTextUpdate,
   isUploadCancellation: () => isUploadCancellation,
+  isUploadConfirmationPending: () => isUploadConfirmationPending,
   isUploadedAttachment: () => isUploadedAttachment,
   isVideoAttachment: () => isVideoAttachment,
   isVoiceRecordingAttachment: () => isVoiceRecordingAttachment,
@@ -247,6 +249,8 @@ __export(src_exports, {
   readFileAsArrayBuffer: () => readFileAsArrayBuffer,
   removeDiacritics: () => removeDiacritics,
   replaceWordWithEntity: () => replaceWordWithEntity,
+  resolveAttachmentFileSize: () => resolveAttachmentFileSize,
+  resolveAttachmentFullByteSize: () => resolveAttachmentFullByteSize,
   settled: () => settled,
   stripCommandFromText: () => stripCommandFromText,
   stripMentionTokens: () => stripMentionTokens,
@@ -389,6 +393,13 @@ var LOCAL_MESSAGE_FIELDS = Object.freeze({ error: true });
 var DEFAULT_QUERY_CHANNELS_RETRY_COUNT = 3;
 var DEFAULT_QUERY_CHANNELS_MS_BETWEEN_RETRIES = 1e3;
 
+// src/formatMessageMemo.ts
+var memo = /* @__PURE__ */ new WeakMap();
+var getMemoizedFormat = (source) => memo.get(source);
+var memoizeFormat = (source, formatted) => {
+  memo.set(source, formatted);
+};
+
 // src/logger.ts
 var scopedLogger = __toESM(require("@stream-io/logger"));
 var import_logger = require("@stream-io/logger");
@@ -594,6 +605,8 @@ var axiosParamsSerializer = (params) => {
   return newParams.join("&");
 };
 function formatMessage(message) {
+  const memoized = getMemoizedFormat(message);
+  if (memoized) return memoized;
   const toLocalMessageBase = (msg) => {
     if (!msg) return null;
     return {
@@ -613,11 +626,13 @@ function formatMessage(message) {
       updated_at: msg.updated_at ?? nowNs()
     };
   };
-  return {
+  const formatted = {
     ...toLocalMessageBase(message),
     error: message.error ?? void 0,
     quoted_message: toLocalMessageBase(message.quoted_message) ?? void 0
   };
+  memoizeFormat(message, formatted);
+  return formatted;
 }
 function computeOwnReactions({
   current,
@@ -1488,7 +1503,12 @@ var EntityStore = class {
       return fn();
     } finally {
       this.transactionDepth -= 1;
-      if (this.transactionDepth === 0) this.flush();
+      if (this.transactionDepth === 0) {
+        this.flush();
+        const ids = this.pendingFlushIds;
+        this.pendingFlushIds = void 0;
+        if (ids) for (const id of ids) this.flushSubscribersNow(id);
+      }
     }
   }
   /**
@@ -1496,8 +1516,19 @@ var EntityStore = class {
    * {@link EntityStoreSubscriber.flushState}). Called after an optimistic (local-user) write to
    * `id` so it renders without the throttle delay. Only that id's own subscribers are flushed — the
    * write touched no other id — and flushing a subscriber with nothing pending is a no-op.
+   *
+   * Inside a transaction it is deferred to the outermost exit — inline there it would be a no-op,
+   * since `markDirty` has not notified anyone yet. Getting this wrong costs the siblings (pinned
+   * list, open thread) up to 500ms on an optimistic write, while the writer updates inline.
    */
   flushSubscribers(id) {
+    if (this.transactionDepth > 0) {
+      (this.pendingFlushIds ?? (this.pendingFlushIds = /* @__PURE__ */ new Set())).add(id);
+      return;
+    }
+    this.flushSubscribersNow(id);
+  }
+  flushSubscribersNow(id) {
     const subscribers = this.subscribers.get(id);
     if (!subscribers) return;
     for (const subscriber of subscribers) subscriber.flushState?.();
@@ -1596,11 +1627,11 @@ var isClassInstance = (value) => {
   if (proto === null || proto === Object.prototype) return false;
   return value.constructor && value.constructor !== Object;
 };
-function memoHasOrAdd(memo, a, b) {
-  const set = memo.get(a);
+function memoHasOrAdd(memo2, a, b) {
+  const set = memo2.get(a);
   if (set && set.has(b)) return true;
   if (set) set.add(b);
-  else memo.set(a, new WeakSet([b]));
+  else memo2.set(a, new WeakSet([b]));
   return false;
 }
 var isEqual = (value1, value2, pairMemo = /* @__PURE__ */ new WeakMap()) => {
@@ -2671,6 +2702,41 @@ var BasePaginator = class {
   scheduleWindowPublish() {
     this._windowPublishThrottle?.throttledFn();
   }
+  /**
+   * Run `fn` with this paginator's window publishes suspended, emitting once on exit.
+   *
+   * A replace is internally remove-then-insert and each half changes the window, so without this one
+   * logical `ingestItem` emits twice.
+   *
+   * `exit` decides how the single emit leaves the scope: `auto` rides the throttle when there is one
+   * (live ops, where successive events should coalesce across the trailing edge), `sync` always
+   * flushes ({@link batch}, whose contract is that a one-shot operation settles in a single update).
+   *
+   * **`lockItemOrder` lists are excluded.** Their emit is not a re-projection but a republish of the
+   * last-published array with the item spliced back at its original index, and exiting through
+   * {@link flushWindowPublish} re-derives from the active interval — reordering the list and dropping
+   * whatever the interval no longer holds, which is the whole point of locking the order.
+   *
+   * Re-entrant: only the outermost scope emits, so an `ingestItem` inside a coalescing `batch`
+   * defers to the batch.
+   */
+  withSingleWindowPublish(fn, { exit = "auto" } = {}) {
+    if (this.config.lockItemOrder) {
+      fn();
+      return;
+    }
+    const isOutermost = this._windowPublishSuspendDepth === 0;
+    this._windowPublishSuspendDepth += 1;
+    try {
+      fn();
+    } finally {
+      this._windowPublishSuspendDepth -= 1;
+    }
+    if (!isOutermost || !this._suspendedWindowDirty) return;
+    this._suspendedWindowDirty = false;
+    if (exit === "auto" && this.isStateThrottled) this.scheduleWindowPublish();
+    else this.flushWindowPublish();
+  }
   /**
    * Flush any pending throttled window + interval-view publishes immediately. No-op when nothing
    * is pending or throttling is off.
@@ -2899,8 +2965,18 @@ var BasePaginator = class {
     const activeInterval = this._itemIntervals.get(this._activeIntervalId);
     if (!activeInterval) return;
     if (this.isStateThrottled) {
-      for (const id of activeInterval.itemIds) {
-        if (changedIds.has(id)) {
+      const currentItems2 = this.items;
+      if (!currentItems2 || currentItems2.length !== activeInterval.itemIds.length) {
+        if (this.intervalHoldsAnyChangedId(activeInterval, changedIds)) {
+          this.scheduleWindowPublish();
+        }
+        return;
+      }
+      for (let i = 0; i < currentItems2.length; i++) {
+        const id = this.getItemId(currentItems2[i]);
+        if (!changedIds.has(id)) continue;
+        const updated = this._itemIndex.get(id);
+        if (!updated || updated !== currentItems2[i]) {
           this.scheduleWindowPublish();
           return;
         }
@@ -2929,11 +3005,8 @@ var BasePaginator = class {
         return;
       }
     }
-    for (const id of activeInterval.itemIds) {
-      if (changedIds.has(id)) {
-        this.state.partialNext({ items: this.intervalToItems(activeInterval) });
-        return;
-      }
+    if (this.intervalHoldsAnyChangedId(activeInterval, changedIds)) {
+      this.state.partialNext({ items: this.intervalToItems(activeInterval) });
     }
   }
   // ---------------------------------------------------------------------------
@@ -3603,6 +3676,13 @@ var BasePaginator = class {
    *  - if this is the active interval, re-emit state.items from interval
    */
   ingestItem(ingestedItem) {
+    let ingested = false;
+    this.withSingleWindowPublish(() => {
+      ingested = this.applyItemIngestion(ingestedItem);
+    });
+    return ingested;
+  }
+  applyItemIngestion(ingestedItem) {
     const id = this.getItemId(ingestedItem);
     const previousItem = this._itemIndex.get(id);
     const previousCoords = this.locateByItem(previousItem || ingestedItem);
@@ -3614,7 +3694,9 @@ var BasePaginator = class {
       removedItemCoordinates = this.removeItemAtCoordinates(previousCoords);
     }
     const itemHasBeenRemoved = !!removedItemCoordinates?.state && removedItemCoordinates.state.currentIndex > -1;
-    this._itemIndex.setOne(ingestedItem);
+    if (this._itemIndex.has(id) || this.matchesFilter(ingestedItem)) {
+      this._itemIndex.setOne(ingestedItem);
+    }
     if (!this.matchesFilter(ingestedItem)) {
       this.shrinkOffsetAfterRemoval(removedItemCoordinates);
       if (!this.isWindowPublishSuspended && this.isStateThrottled && itemHasBeenRemoved)
@@ -3733,16 +3815,7 @@ var BasePaginator = class {
       this._itemIndex.batch(fn);
       return;
     }
-    this._windowPublishSuspendDepth += 1;
-    try {
-      this._itemIndex.batch(fn);
-    } finally {
-      this._windowPublishSuspendDepth -= 1;
-    }
-    if (this._windowPublishSuspendDepth === 0 && this._suspendedWindowDirty) {
-      this._suspendedWindowDirty = false;
-      this.flushWindowPublish();
-    }
+    this.withSingleWindowPublish(() => this._itemIndex.batch(fn), { exit: "sync" });
   }
   // ---------------------------------------------------------------------------
   // Remove / contains
@@ -4359,6 +4432,10 @@ var CORE_NOTIFICATION_TYPE = {
   messageJumpFailed: "api:message:jump:failed",
   /** Jumping to the latest message failed. */
   messageJumpToLatestFailed: "api:message:jumpToLatest:failed",
+  /** Sending a composed message failed. The message stays in the list, marked failed. */
+  messageSendFailed: "api:message:send:failed",
+  /** Saving an edit failed. The edit is kept on the message, marked failed. */
+  messageUpdateFailed: "api:message:update:failed",
   pollCastVoteLimit: "validation:poll:castVote:limit",
   pollCreateFailed: "api:poll:create:failed"
 };
@@ -5021,34 +5098,37 @@ var MessageIntervalPaginator = class extends BasePaginator {
       deletedAt
     }) => {
       const loadedMessages = this.items ?? [];
-      this.batch(() => {
-        for (const message of loadedMessages) {
-          if (message.user?.id === userId) {
-            if (hardDelete) {
-              this.removeItem({ id: message.id });
-            } else {
-              this.ingestItem(
-                toDeletedMessage({
-                  message,
+      this.batch(
+        () => {
+          for (const message of loadedMessages) {
+            if (message.user?.id === userId) {
+              if (hardDelete) {
+                this.removeItem({ id: message.id });
+              } else {
+                this.ingestItem(
+                  toDeletedMessage({
+                    message,
+                    hardDelete,
+                    deletedAt
+                  })
+                );
+              }
+              continue;
+            }
+            if (message.quoted_message?.user?.id === userId && message.quoted_message.type !== "deleted") {
+              this.ingestItem({
+                ...message,
+                quoted_message: toDeletedMessage({
+                  message: formatMessage(message.quoted_message),
                   hardDelete,
                   deletedAt
                 })
-              );
+              });
             }
-            continue;
-          }
-          if (message.quoted_message?.user?.id === userId && message.quoted_message.type !== "deleted") {
-            this.ingestItem({
-              ...message,
-              quoted_message: toDeletedMessage({
-                message: formatMessage(message.quoted_message),
-                hardDelete,
-                deletedAt
-              })
-            });
           }
-        }
-      });
+        },
+        { coalesce: true }
+      );
     };
     /**
      * Ensures quoted-message snapshots across loaded paginator cache are in sync
@@ -5084,6 +5164,7 @@ var MessageIntervalPaginator = class extends BasePaginator {
       this.batch(() => {
         for (const message of this._itemIndex.values()) {
           if (message.user?.id !== user.id) continue;
+          if (message.user === user) continue;
           this._itemIndex.setOne({ ...message, user });
           if (activeIds.has(this.getItemId(message))) activeAffected = true;
         }
@@ -5094,58 +5175,6 @@ var MessageIntervalPaginator = class extends BasePaginator {
         });
       }
     };
-    /**
-     * Apply a reaction WS event (`reaction.new` / `reaction.updated` / `reaction.deleted`) to the
-     * cached message. The event's `message` already carries the server-updated
-     * `reaction_groups` / `latest_reactions`; only `own_reactions` needs local preservation so a
-     * cross-user reaction does not wipe the current user's reactions. This re-homes what
-     * `ChannelState.addReaction` / `removeReaction` used to do off the now-removed
-     * `channel.state.messages` / `channel.state.threads` caches (the same logic backs the thread
-     * paginator via `Thread.messagePaginator`).
-     *
-     * `own_reactions` is seeded from the currently cached item (so another user's reaction keeps ours),
-     * falling back to the event's own_reactions when the message is not loaded — matching the legacy
-     * behavior where `_updateMessage` only mutated a message that existed locally.
-     *
-     * @param params - The reaction event payload.
-     * @param params.message - The reaction event's message, carrying the
-     *   server-computed `reaction_groups` / `latest_reactions`. Ingested as-is except for `own_reactions`.
-     * @param params.reaction - The reaction from the event. Only added to/removed from
-     *   `own_reactions` when its `user_id` is the current user; otherwise the current user's
-     *   `own_reactions` are left untouched.
-     * @param [params.removed=false] - `true` for `reaction.deleted` (remove the reaction from
-     *   `own_reactions`); `false` for `reaction.new` / `reaction.updated` (add it).
-     * @param [params.enforceUnique=false] - When adding, first clear the current user's existing
-     *   `own_reactions` so only the incoming one remains (used by `reaction.updated`, where a user's
-     *   reaction replaces their previous one).
-     *
-     * TODO(reactive-store): reflect reactions ONCE at the store level, not per-paginator. Both the
-     * channel handler (channel.ts) and the thread handler (thread.ts) call this on every reaction.*
-     * event, so a message held in more than one collection (a show_in_channel reply, or the thread
-     * parent) is reflected TWICE: two writes to the same canonical slot, each fanning out to the
-     * other holder (double re-projection) and minting a fresh ref that defeats the reconcile
-     * ref-equality bail. Idempotent (counts come wholesale from the event) so the result is correct,
-     * just wasteful. The store already fans out to every holder, so reflect once (by id, if held) and
-     * retire the per-collection reflect calls + parent path + enforce_unique branch.
-     */
-    this.reflectReaction = ({
-      enforceUnique = false,
-      message,
-      reaction,
-      removed = false
-    }) => {
-      const formatted = formatMessage(message);
-      const existing = this.getItem(formatted.id);
-      const baseOwnReactions = existing?.own_reactions ?? formatted.own_reactions ?? [];
-      const own_reactions = computeOwnReactions({
-        current: baseOwnReactions,
-        enforceUnique,
-        reaction,
-        removed,
-        userId: this.channel.getClient().userId
-      });
-      this.ingestItem({ ...formatted, own_reactions });
-    };
     /**
      * Map a timestamp to a loaded message — the first message in the latest (head) window whose
      * `created_at` is >= `timestamp` (mirrors the legacy `ChannelState.findMessageByTimestamp`
@@ -5883,6 +5912,7 @@ var PENDING_UPLOAD_STATES = [
 ];
 var isPendingUpload = (attachment) => isLocalUploadAttachment(attachment) && PENDING_UPLOAD_STATES.includes(attachment.localMetadata.uploadState);
 var isFinishedUpload = (attachment) => isLocalUploadAttachment(attachment) && attachment.localMetadata.uploadState === "finished";
+var isFailedUpload = (attachment) => isLocalUploadAttachment(attachment) && attachment.localMetadata.uploadState === "failed";
 var isFileAttachment = (attachment, supportedVideoFormat = []) => attachment.type === "file" || !!(attachment.custom?.mime_type && supportedVideoFormat.indexOf(
   attachment.custom?.mime_type
 ) === -1 && attachment.type !== "video");
@@ -5901,6 +5931,27 @@ var isUploadedAttachment = (attachment) => isAudioAttachment(attachment) || isFi
 var isSharedLocationResponseData = (location) => !!location.latitude && !!location.longitude && !!location.channel_cid;
 var isGiphyAttachment = (attachment) => attachment.type === "giphy";
 
+// src/messageComposer/attachmentUtils.ts
+var getAttachmentPreviewUrl = (attachment, ...urls) => {
+  const resolved = urls.find(Boolean);
+  if (resolved) return resolved;
+  return isLocalUploadAttachment(attachment) ? attachment.localMetadata.previewUri : void 0;
+};
+var resolveAttachmentFileSize = (attachment) => attachment?.custom?.file_size ?? attachment?.file_size;
+var resolveAttachmentFullByteSize = (attachment) => {
+  const fromFile = attachment?.localMetadata?.file?.size;
+  if (typeof fromFile === "number" && Number.isFinite(fromFile) && fromFile >= 0) {
+    return fromFile;
+  }
+  const raw = resolveAttachmentFileSize(attachment);
+  if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) return raw;
+  if (typeof raw === "string") {
+    const parsed = parseFloat(raw);
+    if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+  }
+  return void 0;
+};
+
 // src/messageComposer/fileUtils.ts
 var isFile = (fileLike) => !!fileLike.lastModified && !("uri" in fileLike);
 var isFileList = (obj) => {
@@ -6167,6 +6218,12 @@ var import_axios = __toESM(require("axios"));
 var import_state_store7 = require("@stream-io/state-store");
 var logger3 = chatLoggerSystem.getLogger("upload-manager");
 var isUploadCancellation = (error) => import_axios.default.isCancel(error) || error instanceof Error && error.name === "AbortError";
+var isUploadConfirmationPending = (localMetadata) => {
+  if (!localMetadata || localMetadata.uploadState !== "uploading") return false;
+  if (localMetadata.uploadConfirmationPending !== void 0)
+    return localMetadata.uploadConfirmationPending;
+  return localMetadata.uploadProgress !== void 0 && localMetadata.uploadProgress >= 100;
+};
 var initState = () => ({ uploads: {} });
 var upsertById = (uploads, record) => ({
   ...uploads,
@@ -6290,12 +6347,12 @@ var UploadManager = class {
     this.state = new import_state_store7.StateStore(initState());
   }
   resolveAttachmentManager(channelCid) {
-    const colon = channelCid.indexOf(":");
-    if (colon <= 0 || colon === channelCid.length - 1) {
+    const colon = ":";
+    const colonIndex = channelCid.indexOf(colon);
+    if (colonIndex <= 0 || colonIndex === channelCid.length - 1) {
       throw new Error(`Invalid channelCid: ${channelCid}`);
     }
-    const channelType = channelCid.slice(0, colon);
-    const channelId = channelCid.slice(colon + 1);
+    const [channelType, channelId] = channelCid.split(colon);
     return this.client.channel(channelType, channelId).messageComposer.attachmentManager;
   }
   get uploads() {
@@ -7029,13 +7086,15 @@ var composeWithPendingUploads = ({
   composer,
   state
 }) => {
-  const composerIsKeptAsDraft = !!composer.pollId;
+  const composerIsKeptAsDraft = composer.retainsCompositionOnSubmit;
   const relevantAttachments = composer.attachmentManager.attachments.filter(
-    (attachment) => isFinishedUpload(attachment) || !composerIsKeptAsDraft && isPendingUpload(attachment)
+    (attachment) => isFinishedUpload(attachment) || !composerIsKeptAsDraft && (isPendingUpload(attachment) || isFailedUpload(attachment))
   );
   const localAttachments = (state.localMessage.attachments ?? []).concat(
+    // Only a finished upload has a URL of its own. Everything else keeps `localMetadata`, which
+    // is what the message list joins to the live `uploadManager` record and what a retry needs.
     relevantAttachments.map(
-      (attachment) => isPendingUpload(attachment) ? attachment : localAttachmentToAttachment(attachment)
+      (attachment) => isFinishedUpload(attachment) ? localAttachmentToAttachment(attachment) : attachment
     )
   );
   const messageAttachments = (state.message.attachments ?? []).concat(
@@ -7054,21 +7113,6 @@ var composeWithPendingUploads = ({
     } : state.message
   };
 };
-var createSendWithPendingUploadsAttachmentsMiddleware = (composer) => ({
-  allowsPendingUploads: true,
-  id: "stream-io/message-composer-middleware/attachments",
-  handlers: {
-    compose: ({
-      state,
-      next,
-      forward
-    }) => {
-      const { attachmentManager } = composer;
-      if (!attachmentManager) return forward();
-      return next(composeWithPendingUploads({ composer, state }));
-    }
-  }
-});
 var createAttachmentsCompositionMiddleware = (composer) => ({
   id: "stream-io/message-composer-middleware/attachments",
   handlers: {
@@ -7080,6 +7124,9 @@ var createAttachmentsCompositionMiddleware = (composer) => ({
     }) => {
       const { attachmentManager } = composer;
       if (!attachmentManager) return forward();
+      if (attachmentManager.config.pendingUploadsEnabled) {
+        return next(composeWithPendingUploads({ composer, state }));
+      }
       if (attachmentManager.uploadsInProgressCount > 0) {
         composer.client.notifications.addWarning({
           message: "Wait until all attachments have uploaded",
@@ -9805,10 +9852,11 @@ var createLinkPreviewsCompositionMiddleware = (composer) => ({
       const linkPreviews = linkPreviewsManager.loadingPreviews.length > 0 ? [] : linkPreviewsManager.loadedPreviews.map(
         (preview) => LinkPreviewsManager.getPreviewData(preview)
       );
-      const attachments = (state.message.attachments ?? []).concat(
+      const messageAttachments = (state.message.attachments ?? []).concat(
         linkPreviews
       );
-      if (!attachments.length) return forward();
+      const localAttachments = (state.localMessage.attachments ?? []).concat(linkPreviews);
+      if (!messageAttachments.length && !localAttachments.length) return forward();
       const sendOptions = { ...state.sendOptions };
       const skip_enrich_url = !someLinkPreviewsLoading && linkPreviews.length > 0 || someLinkPreviewsDismissed;
       if (skip_enrich_url) {
@@ -9816,14 +9864,14 @@ var createLinkPreviewsCompositionMiddleware = (composer) => ({
       }
       return next({
         ...state,
-        message: {
+        message: messageAttachments.length ? {
           ...state.message,
-          attachments
-        },
-        localMessage: {
+          attachments: messageAttachments
+        } : state.message,
+        localMessage: localAttachments.length ? {
           ...state.localMessage,
-          attachments
-        },
+          attachments: localAttachments
+        } : state.localMessage,
         sendOptions
       });
     }
@@ -10180,13 +10228,6 @@ var MessageComposerMiddlewareExecutor = class extends MiddlewareExecutor {
       createCompositionDataCleanupMiddleware(composer)
     ]);
   }
-  /**
-   * Narrows the base accessor to the composition middleware type, so callers can read the
-   * declarations it carries (`allowsPendingUploads`) without casting.
-   */
-  get installedMiddleware() {
-    return super.installedMiddleware;
-  }
 };
 var MessageDraftComposerMiddlewareExecutor = class extends MiddlewareExecutor {
   constructor({ composer }) {
@@ -11335,6 +11376,7 @@ var DEFAULT_ATTACHMENT_MANAGER_CONFIG = {
   enabled: true,
   fileUploadFilter: () => true,
   maxNumberOfFilesPerMessage: API_MAX_FILES_ALLOWED_PER_MESSAGE,
+  pendingUploadsEnabled: false,
   trackUploadProgress: true
 };
 var DEFAULT_TEXT_COMPOSER_CONFIG = {
@@ -11356,6 +11398,7 @@ var DEFAULT_COMPOSER_CONFIG = deepFreezeConfig({
   linkPreviews: DEFAULT_LINK_PREVIEW_MANAGER_CONFIG,
   location: DEFAULT_LOCATION_COMPOSER_CONFIG,
   polls: DEFAULT_POLL_COMPOSER_CONFIG,
+  retainCompositionOnSubmit: (composer) => !!composer.pollId,
   text: DEFAULT_TEXT_COMPOSER_CONFIG
 });
 
@@ -11918,6 +11961,123 @@ var mergeServerRestrictions = (requested, restrictions, upperBounds) => {
 // src/thread.ts
 var import_state_store18 = require("@stream-io/state-store");
 
+// src/messageOperations/applyReactionLocally.ts
+var applyReactionLocally = (client, {
+  enforceUnique = false,
+  messageId,
+  reaction,
+  removed = false
+}) => {
+  const store = client.messageStore;
+  const user = client.user;
+  const existing = store.get(messageId);
+  if (!user || !existing) return;
+  const now = nowNs();
+  const reactionResponse = {
+    ...reaction,
+    created_at: reaction.created_at ?? now,
+    custom: reaction.custom ?? {},
+    message_id: messageId,
+    score: reaction.score ?? 1,
+    type: reaction.type,
+    updated_at: reaction.updated_at ?? now,
+    user,
+    user_id: user.id
+  };
+  const removedReactions = removed ? existing.own_reactions?.filter((r) => r.type === reactionResponse.type) ?? [] : enforceUnique ? existing.own_reactions ?? [] : [];
+  const withCounts = removed ? messageWithReactionRemoved(existing, reactionResponse) : messageWithReactionAdded(existing, reactionResponse, enforceUnique);
+  const own_reactions = computeOwnReactions({
+    current: existing.own_reactions ?? [],
+    enforceUnique,
+    reaction: reactionResponse,
+    removed,
+    userId: user.id
+  });
+  store.upsert({ ...withCounts, own_reactions });
+  store.flushSubscribers(messageId);
+  const persisted = store.get(messageId);
+  if (persisted) {
+    client.offlineDb?.executeQuerySafely(
+      (db) => removed ? db.deleteReaction({ message: persisted, reaction: reactionResponse }) : enforceUnique ? db.updateReaction({ message: persisted, reaction: reactionResponse }) : db.insertReaction({ message: persisted, reaction: reactionResponse }),
+      { method: "applyReactionLocally" }
+    );
+  }
+  return () => {
+    if (!removed) {
+      applyReactionLocally(client, {
+        messageId,
+        reaction: reactionResponse,
+        removed: true
+      });
+    }
+    for (const removedReaction of removedReactions) {
+      applyReactionLocally(client, {
+        messageId,
+        reaction: removedReaction,
+        removed: false
+      });
+    }
+  };
+};
+
+// src/messageOperations/optimistic.ts
+var isQueuedForReplay = async (client, messageId, types) => {
+  const { offlineDb } = client;
+  if (!offlineDb?.state.getLatestValue().initialized) return false;
+  const pending = await offlineDb.getPendingTasks({ messageId });
+  return !!pending?.some((task) => types.includes(task.type));
+};
+var reconcileHeldMessage = (channel, message) => {
+  if (!message) return;
+  const { messageStore } = channel.getClient();
+  if (!messageStore.has(message.id)) return;
+  messageStore.upsert(formatMessage(message));
+};
+var addReactionOptimistically = async ({
+  channel,
+  messageId,
+  options,
+  reaction
+}) => {
+  const client = channel.getClient();
+  const { created_at, updated_at, ...restOfReaction } = reaction;
+  const undo = applyReactionLocally(client, {
+    enforceUnique: options?.enforce_unique ?? false,
+    messageId,
+    reaction: {
+      ...restOfReaction,
+      ...created_at ? { created_at: dateToNs(created_at) } : {},
+      ...updated_at ? { updated_at: dateToNs(updated_at) } : {}
+    }
+  });
+  try {
+    const response = await channel.sendReaction({ id: messageId, reaction, ...options });
+    reconcileHeldMessage(channel, response?.message);
+  } catch (error) {
+    if (!await isQueuedForReplay(client, messageId, ["send-reaction"])) undo?.();
+    throw error;
+  }
+};
+var deleteReactionOptimistically = async ({
+  channel,
+  messageId,
+  type
+}) => {
+  const client = channel.getClient();
+  const undo = applyReactionLocally(client, {
+    messageId,
+    reaction: { type },
+    removed: true
+  });
+  try {
+    const response = await channel.deleteReaction({ id: messageId, type });
+    reconcileHeldMessage(channel, response?.message);
+  } catch (error) {
+    if (!await isQueuedForReplay(client, messageId, ["delete-reaction"])) undo?.();
+    throw error;
+  }
+};
+
 // src/messageOperations/MessageOperationStatePolicy.ts
 var parseError = (error) => {
   const stringError = JSON.stringify(error);
@@ -12172,15 +12332,57 @@ var MessageOperations = class {
     });
   }
   /**
-   * The shared lifecycle: apply the optimistic state, fire the request, then reconcile or record the
-   * failure. `kind` is threaded through because the three operations want materially different state
-   * transitions — see {@link MessageOperationStatePolicy}.
+   * Resolves any in-flight upload and folds the URLs back into both payloads. A no-op without
+   * {@link MessageOperationsContext.settlePendingUploads} or a pending attachment.
+   */
+  async settlePendingUploads(params) {
+    const settle = this.ctx.settlePendingUploads;
+    const attachments = params.localMessage.attachments;
+    if (!settle || !attachments?.length) return { params };
+    const { attachments: settledAttachments, failureReason } = await settle(attachments);
+    if (settledAttachments === attachments) return { failureReason, params };
+    const wirePayload = "message" in params && params.message ? { message: { ...params.message, attachments: settledAttachments } } : {};
+    return {
+      failureReason,
+      params: {
+        ...params,
+        ...wirePayload,
+        localMessage: { ...params.localMessage, attachments: settledAttachments }
+      }
+    };
+  }
+  /**
+   * Applies the owner's request-ordering policy for this kind, if it supplied one.
+   */
+  withRequestSequencing(kind, request) {
+    return this.ctx.sequenceRequests ? this.ctx.sequenceRequests(kind, request) : request();
+  }
+  /**
+   * The shared lifecycle: apply the optimistic state, settle any attachment upload still in flight,
+   * fire the request, then reconcile or record the failure. `kind` is threaded through because the
+   * three operations want materially different state transitions — see
+   * {@link MessageOperationStatePolicy}.
    */
   async run(kind, params, doRequest) {
     const messageId = params.localMessage.id;
     const optimistic = this.policy.optimistic(kind, params);
+    let effective = params;
     try {
-      const response = await doRequest(params);
+      const response = await this.withRequestSequencing(kind, async () => {
+        if (kind !== "delete") {
+          const settled2 = await this.settlePendingUploads(params);
+          effective = settled2.params;
+          if (settled2.failureReason) throw settled2.failureReason;
+          const settledAttachments = effective.localMessage.attachments;
+          const held = settledAttachments === params.localMessage.attachments ? void 0 : this.ctx.get(messageId);
+          if (held) {
+            const withUrls = { ...held, attachments: settledAttachments };
+            this.ctx.ingest(withUrls);
+            this.ctx.persist(withUrls);
+          }
+        }
+        return await doRequest(effective);
+      });
       this.policy.success({
         kind,
         messageFromResponse: response?.message,
@@ -12192,7 +12394,7 @@ var MessageOperations = class {
       await this.policy.failure({
         error: e,
         kind,
-        localMessage: params.localMessage,
+        localMessage: effective.localMessage,
         messageId,
         optimistic,
         options: params.options
@@ -12200,6 +12402,13 @@ var MessageOperations = class {
       throw e;
     }
   }
+  /*
+   * Each operation resolves its request as `requestFn ?? handlers.<kind> ?? defaults.<kind>`.
+   *
+   * `handlers` is the integrator seam (`ChannelConfig.requestHandlers`). `requestFn` is a direct
+   * injection point for tests; it is not exposed on the public methods because it wins over
+   * `handlers`, so a caller reaching for it would bypass whatever the host SDK registered.
+   */
   async send(params, requestFn) {
     const handlers = this.ctx.handlers();
     const messageToSend = this.normalizeMessage(
@@ -12272,122 +12481,27 @@ var MessageOperations = class {
     const doRequest = requestFn ?? handlers.delete ?? (async (p) => await this.ctx.defaults.delete(p.localMessage.id, p.options));
     return await this.run("delete", params, doRequest);
   }
-};
-
-// src/entityStore/applyReactionLocally.ts
-var applyReactionLocally = (client, {
-  enforceUnique = false,
-  messageId,
-  reaction,
-  removed = false
-}) => {
-  const store = client.messageStore;
-  const user = client.user;
-  const existing = store.get(messageId);
-  if (!user || !existing) return;
-  const now = nowNs();
-  const reactionResponse = {
-    ...reaction,
-    created_at: reaction.created_at ?? now,
-    custom: reaction.custom ?? {},
-    message_id: messageId,
-    score: reaction.score ?? 1,
-    type: reaction.type,
-    updated_at: reaction.updated_at ?? now,
-    user,
-    user_id: user.id
-  };
-  const removedReactions = removed ? existing.own_reactions?.filter((r) => r.type === reactionResponse.type) ?? [] : enforceUnique ? existing.own_reactions ?? [] : [];
-  const withCounts = removed ? messageWithReactionRemoved(existing, reactionResponse) : messageWithReactionAdded(existing, reactionResponse, enforceUnique);
-  const own_reactions = computeOwnReactions({
-    current: existing.own_reactions ?? [],
-    enforceUnique,
-    reaction: reactionResponse,
-    removed,
-    userId: user.id
-  });
-  store.upsert({ ...withCounts, own_reactions });
-  store.flushSubscribers(messageId);
-  const persisted = store.get(messageId);
-  if (persisted) {
-    client.offlineDb?.executeQuerySafely(
-      (db) => removed ? db.deleteReaction({ message: persisted, reaction: reactionResponse }) : enforceUnique ? db.updateReaction({ message: persisted, reaction: reactionResponse }) : db.insertReaction({ message: persisted, reaction: reactionResponse }),
-      { method: "applyReactionLocally" }
-    );
-  }
-  return () => {
-    if (!removed) {
-      applyReactionLocally(client, {
-        messageId,
-        reaction: reactionResponse,
-        removed: true
-      });
-    }
-    for (const removedReaction of removedReactions) {
-      applyReactionLocally(client, {
-        messageId,
-        reaction: removedReaction,
-        removed: false
-      });
-    }
-  };
-};
-
-// src/messageOperations/optimistic.ts
-var isQueuedForReplay = async (client, messageId, types) => {
-  const { offlineDb } = client;
-  if (!offlineDb?.state.getLatestValue().initialized) return false;
-  const pending = await offlineDb.getPendingTasks({ messageId });
-  return !!pending?.some((task) => types.includes(task.type));
-};
-var reconcileHeldMessage = (channel, message) => {
-  if (!message) return;
-  const { messageStore } = channel.getClient();
-  if (!messageStore.has(message.id)) return;
-  messageStore.upsert(formatMessage(message));
-};
-var addReactionOptimistically = async ({
-  channel,
-  messageId,
-  options,
-  reaction
-}) => {
-  const client = channel.getClient();
-  const { created_at, updated_at, ...restOfReaction } = reaction;
-  const undo = applyReactionLocally(client, {
-    enforceUnique: options?.enforce_unique ?? false,
-    messageId,
-    reaction: {
-      ...restOfReaction,
-      ...created_at ? { created_at: dateToNs(created_at) } : {},
-      ...updated_at ? { updated_at: dateToNs(updated_at) } : {}
-    }
-  });
-  try {
-    const response = await channel.sendReaction({ id: messageId, reaction, ...options });
-    reconcileHeldMessage(channel, response?.message);
-  } catch (error) {
-    if (!await isQueuedForReplay(client, messageId, ["send-reaction"])) undo?.();
-    throw error;
+  async retrySendWithLocalUpdate({
+    localMessage,
+    options
+  }) {
+    await this.retry({ localMessage: { ...localMessage, type: "regular" }, options });
   }
-};
-var deleteReactionOptimistically = async ({
-  channel,
-  messageId,
-  type
-}) => {
-  const client = channel.getClient();
-  const undo = applyReactionLocally(client, {
-    messageId,
-    reaction: { type },
-    removed: true
-  });
-  try {
-    const response = await channel.deleteReaction({ id: messageId, type });
-    reconcileHeldMessage(channel, response?.message);
-  } catch (error) {
-    if (!await isQueuedForReplay(client, messageId, ["delete-reaction"])) undo?.();
-    throw error;
+  /**
+   * Adds a reaction with an optimistic local state update — see {@link addReactionOptimistically}.
+   *
+   * The request routes through the channel because reactions are channel-level, while the local write
+   * is addressed by message id and so reaches a pure thread reply that no channel collection holds.
+   */
+  async addReactionWithLocalUpdate(params) {
+    await addReactionOptimistically({ channel: this.ctx.channel, ...params });
+  }
+  /**
+   * Removes the current user's reaction with an optimistic local state update, mirroring
+   * {@link MessageOperations.addReactionWithLocalUpdate}.
+   */
+  async deleteReactionWithLocalUpdate(params) {
+    await deleteReactionOptimistically({ channel: this.ctx.channel, ...params });
   }
 };
 
@@ -12409,6 +12523,210 @@ var createMessageOperationsPersistence = ({
   isQueued: (messageId, types) => isQueuedForReplay(channel.getClient(), messageId, types)
 });
 
+// src/messageOperations/sendOrdering.ts
+var keepSendOrderWhilePendingUploadsAllowed = ({
+  channelCid,
+  composer,
+  kind,
+  request
+}) => (kind === "send" || kind === "retry") && composer.allowsPendingUploads ? withoutConcurrency(`stream-chat/send-message/${channelCid}`, request) : request();
+
+// src/messageOperations/settlePendingAttachmentUploads.ts
+var applyUploadResult = (attachment, response) => {
+  const enriched = { ...attachment };
+  if (isLocalImageAttachment(enriched)) {
+    enriched.image_url = response.file;
+  } else {
+    enriched.asset_url = response.file;
+  }
+  if (response.thumb_url) {
+    enriched.thumb_url = response.thumb_url;
+  }
+  const { previewUri } = attachment.localMetadata;
+  if (previewUri?.startsWith("blob:")) URL.revokeObjectURL?.(previewUri);
+  const { localMetadata: _localMetadata, ...rest } = enriched;
+  return rest;
+};
+var settlePendingAttachmentUploads = async ({
+  attachments,
+  channelCid,
+  client
+}) => {
+  const unsettledIndexes = attachments.reduce((indexes, attachment, index) => {
+    if (isPendingUpload(attachment) || isFailedUpload(attachment)) indexes.push(index);
+    return indexes;
+  }, []);
+  if (!unsettledIndexes.length) return { attachments };
+  const settled2 = await Promise.allSettled(
+    unsettledIndexes.map((index) => {
+      const { file, id } = attachments[index].localMetadata;
+      return client.uploadManager.upload({ channelCid, file, id });
+    })
+  );
+  const nextAttachments = [...attachments];
+  let failureReason;
+  settled2.forEach((result, position) => {
+    const index = unsettledIndexes[position];
+    const attachment = nextAttachments[index];
+    if (result.status === "fulfilled" && result.value) {
+      nextAttachments[index] = applyUploadResult(attachment, result.value);
+      return;
+    }
+    if (!failureReason) {
+      failureReason = result.status === "rejected" ? result.reason : new Error("Attachment upload returned no result");
+    }
+  });
+  return { attachments: nextAttachments, failureReason };
+};
+
+// src/messageOperations/createMessageOperations.ts
+var createMessageOperations = (collection) => {
+  const paginator = collection.messagePaginator;
+  const { channel, parentMessageId } = paginator;
+  return new MessageOperations({
+    sequenceRequests: (kind, request) => keepSendOrderWhilePendingUploadsAllowed({
+      channelCid: channel.cid,
+      composer: collection.messageComposer,
+      kind,
+      request
+    }),
+    settlePendingUploads: (attachments) => settlePendingAttachmentUploads({
+      attachments,
+      // A reply uploads against the channel the thread belongs to - there is no thread-scoped
+      // upload target.
+      channelCid: channel.cid,
+      client: channel.getClient()
+    }),
+    ...createMessageOperationsPersistence({ channel }),
+    channel,
+    ingest: (m) => {
+      const store = channel.getClient().messageStore;
+      if (paginator.matchesFilter(m)) {
+        paginator.ingestItem(m);
+      } else if (store.has(m.id)) {
+        store.upsert(m);
+      }
+      store.flushSubscribers(m.id);
+    },
+    // Mirrors `ingest`'s routing: a message this paginator does not hold can still be held by the
+    // client-global store (a thread parent, a message displayed by another collection), and the
+    // policy uses this both for its freshness comparison and to decide whether there is anything to
+    // update optimistically at all. Reading only the paginator would make those two disagree.
+    get: (id) => paginator.getItem(id) ?? channel.getClient().messageStore.get(id),
+    remove: (id) => {
+      const client = channel.getClient();
+      const parentId = paginator.getItem(id)?.parent_id ?? client.messageStore.get(id)?.parent_id;
+      channel.messagePaginator.removeItem({ id });
+      channel.pinnedMessagesPaginator.removeItem({ id });
+      if (parentId) {
+        client.threads.threadsById[parentId]?.messagePaginator.removeItem({ id });
+      }
+    },
+    ...parentMessageId ? {
+      normalizeOutgoingMessage: (m) => ({ ...m, parent_id: parentMessageId })
+    } : {},
+    handlers: () => {
+      const { requestHandlers } = channel.configState.getLatestValue();
+      const deleteMessageRequest = requestHandlers?.deleteMessageRequest;
+      const sendMessageRequest = requestHandlers?.sendMessageRequest;
+      const retrySendMessageRequest = requestHandlers?.retrySendMessageRequest;
+      const updateMessageRequest = requestHandlers?.updateMessageRequest;
+      return {
+        delete: deleteMessageRequest ? (p) => deleteMessageRequest({
+          localMessage: p.localMessage,
+          options: p.options
+        }) : void 0,
+        send: sendMessageRequest ? (p) => sendMessageRequest({
+          localMessage: p.localMessage,
+          message: p.message,
+          options: p.options
+        }) : void 0,
+        retry: retrySendMessageRequest ? (p) => retrySendMessageRequest({
+          localMessage: p.localMessage,
+          message: p.message,
+          options: p.options
+        }) : void 0,
+        update: updateMessageRequest ? (p) => updateMessageRequest({
+          localMessage: p.localMessage,
+          options: p.options
+        }) : void 0
+      };
+    },
+    defaults: {
+      delete: async (id, o) => {
+        const result = await channel.getClient().deleteMessage({ id, ...o });
+        return { message: result.message };
+      },
+      send: async (m, o) => {
+        const result = await channel.sendMessage({ message: m, ...o });
+        return { message: result.message };
+      },
+      update: async (m, o) => {
+        const result = await channel.getClient().updateMessage({
+          id: m.id,
+          message: localMessageToNewMessagePayload(m),
+          ...o
+        });
+        return { message: result.message };
+      }
+    }
+  });
+};
+
+// src/messageOperations/WithMessageOperations.ts
+var WithMessageOperations = (Base) => {
+  class WithMessageOperationsMixin extends Base {
+    /** Sends a message with optimistic local state update. */
+    async sendMessageWithLocalUpdate(params) {
+      await this.messageOperations.send(params);
+    }
+    /** Retry sending a failed message. */
+    async retrySendMessageWithLocalUpdate(params) {
+      await this.messageOperations.retrySendWithLocalUpdate(params);
+    }
+    /** Updates a message with optimistic local state update. */
+    async updateMessageWithLocalUpdate(params) {
+      await this.messageOperations.update(params);
+    }
+    /** Deletes a message with local state update. */
+    async deleteMessageWithLocalUpdate(params) {
+      await this.messageOperations.delete(params);
+    }
+    /** Adds a reaction with an optimistic local state update. */
+    async addReactionWithLocalUpdate(params) {
+      await this.messageOperations.addReactionWithLocalUpdate(params);
+    }
+    /** Removes the current user's reaction with an optimistic local state update. */
+    async deleteReactionWithLocalUpdate(params) {
+      await this.messageOperations.deleteReactionWithLocalUpdate(params);
+    }
+  }
+  return WithMessageOperationsMixin;
+};
+
+// src/messageOperations/reflectReactionEvent.ts
+var reflectReactionEvent = (client, {
+  enforceUnique = false,
+  message,
+  reaction,
+  removed = false
+}) => {
+  const store = client.messageStore;
+  if (!store.has(message.id)) return;
+  const formatted = formatMessage(message);
+  const existing = store.get(message.id);
+  store.upsert({
+    ...formatted,
+    own_reactions: computeOwnReactions({
+      current: existing?.own_reactions ?? formatted.own_reactions ?? [],
+      enforceUnique,
+      reaction,
+      removed,
+      userId: client.userId
+    })
+  });
+};
+
 // src/configuration/utils/declarativeSlices.ts
 var mergeDeclarativeSlice = (general, specific) => {
   if (!general) return specific;
@@ -12434,7 +12752,7 @@ var DEFAULT_PAGE_LIMIT = 50;
 var DEFAULT_SORT2 = [{ field: "created_at", direction: -1 }];
 var DEFAULT_ITEM_ORDER = [{ field: "created_at", direction: 1 }];
 var DEFAULT_THREAD_CONFIG = deepFreezeConfig({});
-var Thread = class extends WithSubscriptions {
+var Thread = class extends WithMessageOperations(WithSubscriptions) {
   constructor({
     client,
     threadData,
@@ -12786,24 +13104,7 @@ var Thread = class extends WithSubscriptions {
       const unsubscribeReactions = reactionTypes.map(
         (eventType) => this.client.on(eventType, (event) => {
           if (!event.message || !event.reaction) return;
-          const { message, reaction } = event;
-          if (message.parent_id === this.id) {
-            this.messagePaginator.reflectReaction({
-              enforceUnique: eventType === "reaction.updated",
-              message,
-              reaction,
-              removed: eventType === "reaction.deleted"
-            });
-          } else if (!message.parent_id && message.id === this.id) {
-            const own_reactions = computeOwnReactions({
-              current: this.state.getLatestValue().parentMessage?.own_reactions ?? message.own_reactions ?? [],
-              enforceUnique: eventType === "reaction.updated",
-              reaction,
-              removed: eventType === "reaction.deleted",
-              userId: this.client.userId
-            });
-            this.updateParentMessageLocally({ message: { ...message, own_reactions } });
-          }
+          const { message } = event;
           this.messagePaginator.reflectQuotedMessageUpdate(formatMessage(message));
         }).unsubscribe
       );
@@ -12869,6 +13170,7 @@ var Thread = class extends WithSubscriptions {
       } else if (this.failedRepliesMap.has(message.id)) {
         this.failedRepliesMap.delete(message.id);
       }
+      if (this.messagePaginator.getItem(formattedMessage.id) === formattedMessage) return;
       this.messagePaginator.ingestItem(formattedMessage);
     };
     // todo: can be removed with the next breaking change and use MessagePaginator only
@@ -13008,77 +13310,7 @@ var Thread = class extends WithSubscriptions {
       composition: threadData?.draft ?? draft,
       compositionContext: this
     });
-    this.messageOperations = new MessageOperations({
-      ...createMessageOperationsPersistence({ channel: this.channel }),
-      ingest: (m) => {
-        const store = this.channel.getClient().messageStore;
-        if (this.messagePaginator.matchesFilter(m)) {
-          this.messagePaginator.ingestItem(m);
-        } else if (store.has(m.id)) {
-          store.upsert(m);
-        }
-        store.flushSubscribers(m.id);
-      },
-      // Mirrors `ingest`'s routing: a message this paginator does not hold can still be held by the
-      // client-global store (a thread parent, a message displayed by another collection), and the
-      // policy uses this both for its freshness comparison and to decide whether there is anything to
-      // update optimistically at all. Reading only the paginator would make those two disagree.
-      get: (id) => this.messagePaginator.getItem(id) ?? this.channel.getClient().messageStore.get(id),
-      remove: (id) => {
-        this.messagePaginator.removeItem({ id });
-        this.channel.messagePaginator.removeItem({ id });
-        this.channel.pinnedMessagesPaginator.removeItem({ id });
-      },
-      normalizeOutgoingMessage: (m) => ({
-        ...m,
-        parent_id: this.id
-      }),
-      handlers: () => {
-        const { requestHandlers } = this.channel.configState.getLatestValue();
-        const deleteMessageRequest = requestHandlers?.deleteMessageRequest;
-        const sendMessageRequest = requestHandlers?.sendMessageRequest;
-        const retrySendMessageRequest = requestHandlers?.retrySendMessageRequest;
-        const updateMessageRequest = requestHandlers?.updateMessageRequest;
-        return {
-          delete: deleteMessageRequest ? (p) => deleteMessageRequest({
-            localMessage: p.localMessage,
-            options: p.options
-          }) : void 0,
-          send: sendMessageRequest ? (p) => sendMessageRequest({
-            localMessage: p.localMessage,
-            message: p.message,
-            options: p.options
-          }) : void 0,
-          retry: retrySendMessageRequest ? (p) => retrySendMessageRequest({
-            localMessage: p.localMessage,
-            message: p.message,
-            options: p.options
-          }) : void 0,
-          update: updateMessageRequest ? (p) => updateMessageRequest({
-            localMessage: p.localMessage,
-            options: p.options
-          }) : void 0
-        };
-      },
-      defaults: {
-        delete: async (id, o) => {
-          const result = await this.channel.getClient().deleteMessage({ id, ...o });
-          return { message: result.message };
-        },
-        send: async (m, o) => {
-          const result = await this.channel.sendMessage({ message: m, ...o });
-          return { message: result.message };
-        },
-        update: async (m, o) => {
-          const result = await this.channel.getClient().updateMessage({
-            id: m.id,
-            message: localMessageToNewMessagePayload(m),
-            ...o
-          });
-          return { message: result.message };
-        }
-      }
-    });
+    this.messageOperations = createMessageOperations(this);
     this.initializeConfig(declarativeConfig);
   }
   /**
@@ -13133,90 +13365,6 @@ var Thread = class extends WithSubscriptions {
   get ownUnreadCount() {
     return ownUnreadCountSelector(this.client.userId)(this.state.getLatestValue());
   }
-  /**
-   * Sends a message with optimistic local state update.
-   */
-  async sendMessageWithLocalUpdate({
-    localMessage,
-    message,
-    options,
-    sendMessageRequestFn
-  }) {
-    await this.messageOperations.send(
-      {
-        localMessage,
-        message,
-        options
-      },
-      sendMessageRequestFn
-    );
-  }
-  /**
-   * Retry sending a failed message.
-   */
-  async retrySendMessageWithLocalUpdate(params) {
-    await this.messageOperations.retry(
-      {
-        localMessage: { ...params.localMessage, type: "regular" },
-        options: params.options
-      },
-      params.sendMessageRequestFn
-    );
-  }
-  /**
-   * Updates a message with optimistic local state update.
-   *
-   * The update flows through `messagePaginator`, which is the sole reply source.
-   */
-  async updateMessageWithLocalUpdate(params) {
-    await this.messageOperations.update(
-      {
-        localMessage: params.localMessage,
-        options: params.options
-      },
-      params.updateMessageRequestFn
-    );
-  }
-  /**
-   * Deletes a message with local state update.
-   */
-  async deleteMessageWithLocalUpdate(params) {
-    await this.messageOperations.delete(
-      {
-        localMessage: params.localMessage,
-        options: params.options
-      },
-      params.deleteMessageRequestFn
-    );
-  }
-  /**
-   * Adds a reaction to a reply with an optimistic local state update — see
-   * {@link addReactionOptimistically}, which `Channel` shares. The request routes through the parent
-   * channel because reactions are channel-level, while the local write is addressed by message id and
-   * so reaches a pure reply no channel collection holds.
-   */
-  async addReactionWithLocalUpdate({
-    messageId,
-    reaction,
-    options
-  }) {
-    await addReactionOptimistically({
-      channel: this.channel,
-      messageId,
-      options,
-      reaction
-    });
-  }
-  /**
-   * Removes the current user's reaction from a reply with an optimistic local state update — see
-   * {@link deleteReactionOptimistically}, which `Channel` shares.
-   */
-  async deleteReactionWithLocalUpdate({
-    messageId,
-    type
-  }) {
-    await deleteReactionOptimistically({ channel: this.channel, messageId, type });
-  }
 };
 var normalizeThreadParticipants = (participants, channelCid) => {
   if (!participants) return void 0;
@@ -13808,6 +13956,99 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
         throw error;
       }
     };
+    /**
+     * Lets go of what the submitted message took with it.
+     *
+     * A poll message carries no text or attachments of its own, so the composer keeps whatever else
+     * was drafted and releases only the poll. Everything else is a full clear.
+     */
+    this.releaseSubmittedComposition = () => {
+      if (this.retainsCompositionOnSubmit) {
+        this.state.partialNext({
+          id: _MessageComposer.generateId(),
+          // Unconditional, and safe whatever decided to retain: a poll that exists is always a poll
+          // that just went out, because `createMessageComposerStateCompositionMiddleware` copies a
+          // set `pollId` onto every composition - threads and edits included, where the poll-only
+          // middleware forwards. There is no state where this detaches one the submission did not
+          // carry.
+          //
+          // Detaching it is also not optional. While `pollId` is set, `hasSendableData` counts it as
+          // content on its own and `createPollOnlyCompositionMiddleware` turns every composition
+          // into a poll-only message, so a composer left bound to a spent poll nullifies whatever is
+          // typed next and re-sends the same poll.
+          pollId: null
+        });
+        return;
+      }
+      this.clear();
+    };
+    this.reportSubmitFailure = (type, message, error) => {
+      this.client.notifications.addError({
+        message,
+        origin: {
+          emitter: "MessageComposer",
+          context: { composer: this }
+        },
+        options: {
+          type,
+          metadata: { reason: error.message },
+          originalError: error instanceof Error ? error : void 0
+        }
+      });
+    };
+    /**
+     * Composes the message and sends it, releasing the composer as it goes.
+     *
+     * Never rejects - see {@link MessageComposerSubmitResult} for what each outcome means and where
+     * the content ends up. A failure is reported through `client.notifications`, and the message
+     * stays in the list marked `failed`, which is where the user retries it. Callers rendering their
+     * own post-send feedback have to check the result.
+     */
+    this.send = async () => {
+      const composition = await this.compose();
+      if (!composition?.message) return "nothing-to-send";
+      const { localMessage, message, sendOptions } = composition;
+      this.releaseSubmittedComposition();
+      try {
+        await this.defaultSubmitTarget.sendMessageWithLocalUpdate({
+          localMessage,
+          message,
+          options: sendOptions
+        });
+        return "sent";
+      } catch (error) {
+        this.reportSubmitFailure(
+          CORE_NOTIFICATION_TYPE.messageSendFailed,
+          "Send message request failed",
+          error
+        );
+        return "failed";
+      }
+    };
+    /**
+     * Composes the edit and saves it, on the same terms as {@link send} - including releasing the
+     * composer before the request rather than after it.
+     */
+    this.update = async () => {
+      const composition = await this.compose();
+      if (!composition?.message) return "nothing-to-send";
+      const { localMessage, sendOptions } = composition;
+      this.releaseSubmittedComposition();
+      try {
+        await this.defaultSubmitTarget.updateMessageWithLocalUpdate({
+          localMessage,
+          options: sendOptions
+        });
+        return "sent";
+      } catch (error) {
+        this.reportSubmitFailure(
+          CORE_NOTIFICATION_TYPE.messageUpdateFailed,
+          "Edit message request failed",
+          error
+        );
+        return "failed";
+      }
+    };
     this.sendLocation = async () => {
       const location = this.locationComposer.validLocation;
       if (this.threadId || !location) return;
@@ -13900,9 +14141,6 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     if (compositionContext instanceof Thread) {
       return "thread";
     }
-    if (typeof compositionContext.legacyThreadId === "string") {
-      return "legacy_thread";
-    }
     return "message";
   }
   static constructTag(compositionContext) {
@@ -13938,9 +14176,6 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     if (this.compositionContext instanceof Thread) {
       return this.compositionContext.id;
     }
-    if (typeof this.compositionContext.legacyThreadId === "string") {
-      return this.compositionContext.legacyThreadId;
-    }
     if (typeof this.compositionContext.parent_id === "string") {
       return this.compositionContext.parent_id;
     }
@@ -13972,27 +14207,41 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     return !currentCommand || this.validateCommandSendability(currentCommand).ready;
   }
   /**
-   * Whether the installed composition middleware composes messages whose uploads are still in
-   * flight — see `MessageCompositionMiddleware.allowsPendingUploads`.
+   * Whether a message may be sent while its attachments are still uploading — see
+   * {@link AttachmentManagerConfig.pendingUploadsEnabled}.
+   */
+  get allowsPendingUploads() {
+    return this.attachmentManager.config.pendingUploadsEnabled;
+  }
+  /**
+   * Where a composed message goes: the thread when this composer belongs to one, the channel
+   * otherwise.
    *
-   * Derived from the chain rather than from config, so there is exactly one switch: the UI SDK
-   * that implements the rest of the flow installs the middleware, and everything that has to
-   * follow from that (starting with {@link hasSendableData}) follows on its own.
+   * Thread replies live in `thread.messagePaginator`, which is independent of the channel's, so
+   * dispatching to the wrong one leaves the reply invisible where it was written. An edit composer
+   * is built from the message rather than from its thread, so it can only find the thread when the
+   * manager has it loaded. No composer reachable from a UI SDK is built that way today.
+   */
+  get defaultSubmitTarget() {
+    if (this.compositionContext instanceof Thread) return this.compositionContext;
+    const { threadId } = this;
+    return threadId && this.client.threads.threadsById[threadId] || this.channel;
+  }
+  /**
+   * Whether submitting keeps the composer's contents rather than clearing them - see
+   * {@link MessageComposerConfig.retainCompositionOnSubmit}.
    *
-   * **Temporary API.** In v10 sending with pending uploads becomes part of the composer
-   * configuration (`MessageComposerConfig`, set through `updateConfig`), and this getter,
-   * together with the middleware declaration it reads, is replaced by that config field.
+   * Read by the attachments composition step too: content the composer keeps must not also ride
+   * along on the submitted message, or one `localMetadata.id` ends up owned in two places.
    */
-  get allowsPendingUploads() {
-    return this.compositionMiddlewareExecutor.installedMiddleware.some(
-      (middleware) => middleware.allowsPendingUploads
-    );
+  get retainsCompositionOnSubmit() {
+    return this.config.retainCompositionOnSubmit(this);
   }
   get hasSendableData() {
     if (!this.isCommandSendable) return false;
     if (this.allowsPendingUploads) {
       const hasSendableAttachment = this.attachmentManager.attachments.some(
-        (attachment) => isFinishedUpload(attachment) || isPendingUpload(attachment)
+        (attachment) => isFinishedUpload(attachment) || isPendingUpload(attachment) || isFailedUpload(attachment)
       );
       return !!(!this.textComposer.textIsEmpty || hasSendableAttachment || this.pollId || this.locationComposer.validLocation);
     }
@@ -14462,7 +14711,9 @@ var MessageReceiptsTracker = class extends WithSubscriptions {
     this.snapshotStore = new import_state_store20.StateStore({
       revision: 0,
       readersByMessageId: {},
-      deliveredByMessageId: {}
+      deliveredByMessageId: {},
+      lastDeliveredRefByOthers: null,
+      lastReadRefByOthers: null
     });
     this.registerSubscriptions = () => {
       this.incrementRefCount();
@@ -14658,6 +14909,21 @@ var MessageReceiptsTracker = class extends WithSubscriptions {
     );
     return this.deliveredSorted.slice(pos).map((x) => x.user);
   }
+  /**
+   * Whether at least one other member has this message delivered.
+   *
+   * Reads the single furthest cursor rather than asking who is past this message, so the answer is
+   * monotonic by construction: an older message can never report less than a newer one.
+   */
+  isDeliveredToOthers(msgRef) {
+    const ref = this.snapshotStore.getLatestValue().lastDeliveredRefByOthers;
+    return !!ref && compareRefsAsc(msgRef, ref) <= 0;
+  }
+  /** As {@link isDeliveredToOthers}, for reads. */
+  isReadByOthers(msgRef) {
+    const ref = this.snapshotStore.getLatestValue().lastReadRefByOthers;
+    return !!ref && compareRefsAsc(msgRef, ref) <= 0;
+  }
   /** Users who delivered but have NOT read. */
   deliveredNotReadForMessage(msgRef) {
     const pos = findIndex(
@@ -14833,6 +15099,19 @@ var MessageReceiptsTracker = class extends WithSubscriptions {
       []
     );
   }
+  /**
+   * The furthest ref in an ascending-by-cursor array, ignoring this user's own progress - your own
+   * cursor says nothing about whether anyone received the message.
+   */
+  furthestRefByOthers(sorted, refOf) {
+    const ownUserId = this.channel.getClient().userID;
+    for (let i = sorted.length - 1; i >= 0; i -= 1) {
+      if (sorted[i].user.id === ownUserId) continue;
+      const ref = refOf(sorted[i]);
+      return Number.isFinite(ref.timestamp) ? ref : null;
+    }
+    return null;
+  }
   emitSnapshot() {
     const readersByMessageId = this.groupUsersByLastReadMessage();
     const deliveredByMessageId = this.groupUsersByLastDeliveredMessage();
@@ -14840,7 +15119,15 @@ var MessageReceiptsTracker = class extends WithSubscriptions {
     this.snapshotStore.next({
       revision: currentSnapshot.revision + 1,
       readersByMessageId,
-      deliveredByMessageId
+      deliveredByMessageId,
+      lastDeliveredRefByOthers: this.furthestRefByOthers(
+        this.deliveredSorted,
+        ({ lastDeliveredRef }) => lastDeliveredRef
+      ),
+      lastReadRefByOthers: this.furthestRefByOthers(
+        this.readSorted,
+        ({ lastReadRef }) => lastReadRef
+      )
     });
   }
 };
@@ -15164,7 +15451,7 @@ var DEFAULT_CHANNEL_CONFIG = deepFreezeConfig({
   typingEvents: { enabled: true },
   userMessageReminders: { enabled: true }
 });
-var Channel = class extends ChannelApi {
+var Channel = class extends WithMessageOperations(ChannelApi) {
   /**
    * Creates a `Channel` instance bound to the given chat client.
    *
@@ -15277,78 +15564,7 @@ var Channel = class extends ChannelApi {
     this.messageReceiptsTracker.registerSubscriptions();
     this.cooldownTimer = new CooldownTimer({ channel: this });
     this.cooldownTimer.registerSubscriptions();
-    this.messageOperations = new MessageOperations({
-      ...createMessageOperationsPersistence({ channel: this }),
-      ingest: (m) => {
-        const store = this.getClient().messageStore;
-        if (this.messagePaginator.matchesFilter(m)) {
-          this.messagePaginator.ingestItem(m);
-        } else if (store.has(m.id)) {
-          store.upsert(m);
-        }
-        store.flushSubscribers(m.id);
-      },
-      // Mirrors `ingest`'s routing: a message this paginator does not hold can still be held by the
-      // client-global store (a thread parent, a message displayed by another collection), and the
-      // policy uses this both for its freshness comparison and to decide whether there is anything to
-      // update optimistically at all. Reading only the paginator would make those two disagree.
-      get: (id2) => this.messagePaginator.getItem(id2) ?? this.getClient().messageStore.get(id2),
-      remove: (id2) => {
-        const parentId = this.messagePaginator.getItem(id2)?.parent_id ?? this.getClient().messageStore.get(id2)?.parent_id;
-        this.messagePaginator.removeItem({ id: id2 });
-        this.pinnedMessagesPaginator.removeItem({ id: id2 });
-        if (parentId) {
-          this.getClient().threads.threadsById[parentId]?.messagePaginator.removeItem({
-            id: id2
-          });
-        }
-      },
-      handlers: () => {
-        const { requestHandlers } = this.configState.getLatestValue();
-        const deleteMessageRequest = requestHandlers?.deleteMessageRequest;
-        const sendMessageRequest = requestHandlers?.sendMessageRequest;
-        const retrySendMessageRequest = requestHandlers?.retrySendMessageRequest;
-        const updateMessageRequest = requestHandlers?.updateMessageRequest;
-        return {
-          delete: deleteMessageRequest ? (p) => deleteMessageRequest({
-            localMessage: p.localMessage,
-            options: p.options
-          }) : void 0,
-          send: sendMessageRequest ? (p) => sendMessageRequest({
-            localMessage: p.localMessage,
-            message: p.message,
-            options: p.options
-          }) : void 0,
-          retry: retrySendMessageRequest ? (p) => retrySendMessageRequest({
-            localMessage: p.localMessage,
-            message: p.message,
-            options: p.options
-          }) : void 0,
-          update: updateMessageRequest ? (p) => updateMessageRequest({
-            localMessage: p.localMessage,
-            options: p.options
-          }) : void 0
-        };
-      },
-      defaults: {
-        delete: async (id2, o) => {
-          const result = await this.getClient().deleteMessage({ id: id2, ...o });
-          return { message: result.message };
-        },
-        send: async (m, o) => {
-          const result = await this.sendMessage({ message: m, ...o });
-          return { message: result.message };
-        },
-        update: async (m, o) => {
-          const result = await this.getClient().updateMessage({
-            id: m.id,
-            message: localMessageToNewMessagePayload(m),
-            ...o
-          });
-          return { message: result.message };
-        }
-      }
-    });
+    this.messageOperations = createMessageOperations(this);
     this._syncMuteStatus();
     this.configController = new ConfigController({
       defaults: DEFAULT_CHANNEL_CONFIG,
@@ -15529,74 +15745,16 @@ var Channel = class extends ChannelApi {
     });
   }
   /**
-   * Sends a message with optimistic local state update.
+   * Sends a message with optimistic local state update, stopping the typing indicator first.
+   *
+   * The only collection-specific part of the optimistic API: typing is a channel concern and a
+   * `Thread` has no counterpart, so it is an override rather than part of the mixin.
    */
   async sendMessageWithLocalUpdate(params) {
-    await this.messageOperations.send(
-      {
-        localMessage: params.localMessage,
-        message: params.message,
-        options: params.options
-      },
-      params.sendMessageRequestFn
-    );
-    if (this.messageComposer.config.text.publishTypingEvents) await this.stopTyping();
-  }
-  /**
-   * Retry sending a failed message.
-   */
-  async retrySendMessageWithLocalUpdate(params) {
-    await this.messageOperations.retry(
-      {
-        localMessage: { ...params.localMessage, type: "regular" },
-        options: params.options
-      },
-      params.sendMessageRequestFn
-    );
-  }
-  /**
-   * Updates a message with optimistic local state update.
-   */
-  async updateMessageWithLocalUpdate(params) {
-    await this.messageOperations.update(
-      {
-        localMessage: params.localMessage,
-        options: params.options
-      },
-      params.updateMessageRequestFn
-    );
-  }
-  /**
-   * Deletes a message with local state update.
-   */
-  async deleteMessageWithLocalUpdate(params) {
-    await this.messageOperations.delete(
-      {
-        localMessage: params.localMessage,
-        options: params.options
-      },
-      params.deleteMessageRequestFn
-    );
-  }
-  /**
-   * Adds a reaction with an optimistic local state update - see {@link addReactionOptimistically}.
-   */
-  async addReactionWithLocalUpdate({
-    messageId,
-    reaction,
-    options
-  }) {
-    await addReactionOptimistically({ channel: this, messageId, options, reaction });
-  }
-  /**
-   * Removes the current user's reaction with an optimistic local state update - see
-   * {@link deleteReactionOptimistically}.
-   */
-  async deleteReactionWithLocalUpdate({
-    messageId,
-    type
-  }) {
-    await deleteReactionOptimistically({ channel: this, messageId, type });
+    if (this.messageComposer.config.text.publishTypingEvents) {
+      this.stopTyping().catch(() => void 0);
+    }
+    await super.sendMessageWithLocalUpdate(params);
   }
   /**
    * Upload a file to this channel's file endpoint (multipart).
@@ -16927,8 +17085,8 @@ var Channel = class extends ChannelApi {
               this.messagePaginator.removeItem({ id: event.message.id });
               this.pinnedMessagesPaginator.removeItem({ id: event.message.id });
             } else {
-              this.messagePaginator.ingestItem(formattedMessage);
-              this.pinnedMessagesPaginator.ingestItem(formattedMessage);
+              const store = this.getClient().messageStore;
+              if (store.has(event.message.id)) store.upsert(formattedMessage);
             }
           }
           this.messagePaginator.reflectQuotedMessageUpdate(formattedMessage);
@@ -16957,8 +17115,9 @@ var Channel = class extends ChannelApi {
           const ownMessage = event.user?.id === client.user?.id;
           const isThreadMessage = event.message.parent_id && !event.message.show_in_channel;
           if (!isThreadMessage) {
-            this.messagePaginator.ingestItem(formatMessage(event.message));
-            this.pinnedMessagesPaginator.ingestItem(formatMessage(event.message));
+            const formattedMessage = formatMessage(event.message);
+            this.messagePaginator.ingestItem(formattedMessage);
+            this.pinnedMessagesPaginator.ingestItem(formattedMessage);
           }
           const preventUnreadCountUpdate = ownMessage || isThreadMessage;
           if (preventUnreadCountUpdate) break;
@@ -17038,8 +17197,9 @@ var Channel = class extends ChannelApi {
           this.pinnedMessagesPaginator.clearStateAndCache();
         }
         if (event.message) {
-          this.messagePaginator.ingestItem(formatMessage(event.message));
-          this.pinnedMessagesPaginator.ingestItem(formatMessage(event.message));
+          const formattedMessage = formatMessage(event.message);
+          this.messagePaginator.ingestItem(formattedMessage);
+          this.pinnedMessagesPaginator.ingestItem(formattedMessage);
         }
         break;
       }
@@ -17120,49 +17280,16 @@ var Channel = class extends ChannelApi {
         }
         break;
       case "reaction.new":
-        if (event.message && event.reaction) {
-          const { reaction } = event;
-          if (!event.message?.parent_id || event.message.show_in_channel) {
-            this.messagePaginator.reflectReaction({ message: event.message, reaction });
-            this.pinnedMessagesPaginator.reflectReaction({
-              message: event.message,
-              reaction
-            });
-          }
-        }
-        break;
-      case "reaction.deleted":
-        if (event.message && event.reaction) {
-          const { reaction } = event;
-          if (event.message && (!event.message.parent_id || event.message.show_in_channel)) {
-            this.messagePaginator.reflectReaction({
-              message: event.message,
-              reaction,
-              removed: true
-            });
-            this.pinnedMessagesPaginator.reflectReaction({
-              message: event.message,
-              reaction,
-              removed: true
-            });
-          }
-        }
-        break;
       case "reaction.updated":
+      case "reaction.deleted":
         if (event.message && event.reaction) {
-          const { reaction } = event;
-          if (!event.message?.parent_id || event.message.show_in_channel) {
-            this.messagePaginator.reflectReaction({
-              enforceUnique: true,
-              message: event.message,
-              reaction
-            });
-            this.pinnedMessagesPaginator.reflectReaction({
-              enforceUnique: true,
-              message: event.message,
-              reaction
-            });
-          }
+          reflectReactionEvent(this.getClient(), {
+            // reaction.updated is only sent when enforce_unique is set
+            enforceUnique: event.type === "reaction.updated",
+            message: event.message,
+            reaction: event.reaction,
+            removed: event.type === "reaction.deleted"
+          });
         }
         break;
       case "channel.hidden": {
@@ -24277,7 +24404,7 @@ var StreamChat = class _StreamChat extends ChatApi {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "10.0.0-rc.12";
+        const version = "10.0.0-rc.13";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -25473,6 +25600,11 @@ var ATTACHMENTS_FIELDS = {
     kind: "value",
     type: "number"
   },
+  pendingUploadsEnabled: {
+    description: "Lets a message be sent while its attachments are still uploading. The message appears immediately and the request waits for the uploads; one failed upload fails the message.",
+    kind: "value",
+    type: "boolean"
+  },
   trackUploadProgress: {
     description: "Reports upload progress on each attachment. Turning it off skips the progress bookkeeping.",
     kind: "value",
@@ -25593,6 +25725,11 @@ var MESSAGE_COMPOSER_FIELDS = {
     fields: POLLS_FIELDS,
     kind: "group"
   },
+  retainCompositionOnSubmit: {
+    description: "Decides whether submitting keeps the composer's contents instead of clearing them. Retains for a poll message by default.",
+    kind: "value",
+    type: "function"
+  },
   text: { description: "The text input itself.", fields: TEXT_FIELDS, kind: "group" }
 };
 var MESSAGE_DELIVERY_FIELDS = {