stream-chat 9.50.3 → 9.52.0

package/dist/esm/index.mjs

@@ -316,7 +316,7 @@ var ChannelBatchUpdater = class {
 
 // src/client.ts
 var import_https = __toESM(require_https());
-import axios3 from "axios";
+import axios4 from "axios";
 
 // src/utils.ts
 import FormData from "form-data";
@@ -575,6 +575,38 @@ function unformatMessage(message) {
     quoted_message: toMessageResponseBase(message.quoted_message)
   };
 }
+var isRemoteUrl = (url) => !!url && /^https?:\/\//i.test(url.trim());
+var sanitizeOutgoingAttachments = ({
+  client,
+  message
+}) => {
+  const attachments = message.attachments;
+  if (!attachments?.length) return message;
+  const unresolved = [];
+  let changed = false;
+  const sanitized = attachments.reduce((acc, attachment) => {
+    const { localMetadata, ...rest } = attachment;
+    if (!localMetadata) {
+      acc.push(attachment);
+      return acc;
+    }
+    changed = true;
+    const hasRemoteSource = isRemoteUrl(rest.asset_url) || isRemoteUrl(rest.image_url) || isRemoteUrl(rest.og_scrape_url) || isRemoteUrl(rest.title_link);
+    if (hasRemoteSource) {
+      acc.push(rest);
+    } else {
+      unresolved.push(rest);
+    }
+    return acc;
+  }, []);
+  if (unresolved.length) {
+    const text = `Dropped ${unresolved.length} attachment(s) whose upload never completed. Composing with pending uploads requires awaiting them before sending.`;
+    const extraData = { attachments: unresolved, message, tags: ["attachments"] };
+    client.logger("warn", text, extraData);
+    console.warn(text, extraData);
+  }
+  return changed ? { ...message, attachments: sanitized } : message;
+};
 var localMessageToNewMessagePayload = (localMessage) => {
   const {
     // Remove all timestamp fields and client-specific fields.
@@ -783,7 +815,8 @@ var debounce = (fn, timeout = 0, { leading = false, trailing = true } = {}) => {
       }
       runningTimeout = null;
     };
-    runningTimeout = setTimeout(timeoutHandler, timeout);
+    const delay = typeof timeout === "function" ? timeout(...args) : timeout;
+    runningTimeout = setTimeout(timeoutHandler, delay);
     return lastResult;
   };
   debouncedFn.cancel = () => {
@@ -2346,6 +2379,12 @@ var CooldownTimer = class extends WithSubscriptions {
 var isScrapedContent = (attachment) => !!attachment?.og_scrape_url || !!attachment?.title_link;
 var isLocalAttachment = (attachment) => !!attachment?.localMetadata?.id;
 var isLocalUploadAttachment = (attachment) => !!attachment?.localMetadata?.uploadState;
+var PENDING_UPLOAD_STATES = [
+  "pending",
+  "uploading"
+];
+var isPendingUpload = (attachment) => isLocalUploadAttachment(attachment) && PENDING_UPLOAD_STATES.includes(attachment.localMetadata.uploadState);
+var isFinishedUpload = (attachment) => isLocalUploadAttachment(attachment) && attachment.localMetadata.uploadState === "finished";
 var isFileAttachment = (attachment, supportedVideoFormat = []) => attachment.type === "file" || !!(attachment.mime_type && supportedVideoFormat.indexOf(attachment.mime_type) === -1 && attachment.type !== "video");
 var isLocalFileAttachment = (attachment) => isFileAttachment(attachment) && isLocalAttachment(attachment);
 var isImageAttachment = (attachment) => attachment.type === "image" && !isScrapedContent(attachment);
@@ -2421,7 +2460,7 @@ var ensureIsLocalAttachment = (attachment) => {
 };
 
 // src/messageComposer/middleware/attachmentManager/postUpload/attachmentEnrichment.ts
-var createPostUploadAttachmentEnrichmentMiddleware = () => ({
+var createPostUploadAttachmentEnrichmentMiddleware = (composer) => ({
   id: "stream-io/attachment-manager-middleware/post-upload-enrichment",
   handlers: {
     postProcess: ({
@@ -2434,9 +2473,10 @@ var createPostUploadAttachmentEnrichmentMiddleware = () => ({
       if (error) return forward();
       if (!attachment || !response) return discard();
       const enrichedAttachment = { ...attachment };
-      const previewUri = attachment.localMetadata.previewUri;
-      if (previewUri) {
-        if (previewUri.startsWith("blob:")) URL.revokeObjectURL(previewUri);
+      const { id, previewUri } = attachment.localMetadata;
+      const attachmentIsStillInComposer = !composer || !!composer.attachmentManager.attachmentsById[id];
+      if (previewUri && attachmentIsStillInComposer) {
+        if (previewUri.startsWith("blob:")) URL.revokeObjectURL?.(previewUri);
         delete enrichedAttachment.localMetadata.previewUri;
       }
       if (isLocalImageAttachment(attachment)) {
@@ -2459,6 +2499,12 @@ var createPostUploadAttachmentEnrichmentMiddleware = () => ({
 var withoutConcurrency = createRunner(wrapWithContinuationTracking);
 var withCancellation = createRunner(wrapWithCancellation);
 var pendingPromises = /* @__PURE__ */ new Map();
+function hasPending(tag) {
+  return pendingPromises.has(tag);
+}
+async function settled(tag) {
+  await pendingPromises.get(tag)?.promise;
+}
 function createRunner(wrapper) {
   return function run(tag, cb) {
     const { cb: wrapped, onContinued } = wrapper(tag, cb);
@@ -2501,6 +2547,16 @@ var MiddlewareExecutor = class {
     this.middleware = [];
     this.id = generateUUIDv4();
   }
+  /**
+   * The middleware currently installed, in execution order.
+   *
+   * Read-only: use `use` / `insert` / `replace` / `setOrder` / `remove` to change the chain. It
+   * exists so components can ask what the chain is capable of - a middleware may declare
+   * behaviour its host has to account for, and the host has no other way to find out.
+   */
+  get installedMiddleware() {
+    return this.middleware;
+  }
   use(middleware) {
     this.middleware = this.middleware.concat(middleware);
     return this;
@@ -2604,6 +2660,142 @@ var MiddlewareExecutor = class {
   }
 };
 
+// src/uploadManager.ts
+import axios from "axios";
+var isUploadCancellation = (error) => axios.isCancel(error) || error instanceof Error && error.name === "AbortError";
+var initState = () => ({ uploads: {} });
+var upsertById = (uploads, record) => ({
+  ...uploads,
+  [record.id]: { ...uploads[record.id], ...record }
+});
+var updateById = (uploads, record) => {
+  if (!(record.id in uploads)) return null;
+  const current = uploads[record.id];
+  return { ...uploads, [record.id]: { ...current, ...record } };
+};
+var UploadManager = class {
+  constructor(client) {
+    this.client = client;
+    this.inFlightUploads = /* @__PURE__ */ new Map();
+    this.getUpload = (id) => this.uploads[id];
+    /**
+     * Clears all upload records.
+     * Invoked when the user disconnects so a later session does not inherit stale upload state.
+     * Aborts every in-flight upload request via its `UploadRequestOptions.abortSignal`.
+     */
+    this.reset = () => {
+      for (const { abortController } of this.inFlightUploads.values()) {
+        abortController.abort();
+      }
+      this.inFlightUploads.clear();
+      this.state.next(initState());
+    };
+    /**
+     * Removes the upload record for `id` if present.
+     * If an upload is still in progress, aborts its `UploadRequestOptions.abortSignal`.
+     */
+    this.deleteUploadRecord = (id) => {
+      const flight = this.inFlightUploads.get(id);
+      if (flight) {
+        this.inFlightUploads.delete(id);
+        flight.abortController.abort();
+      }
+      this.state.next((current) => {
+        if (!(id in current.uploads)) return current;
+        const uploads = { ...current.uploads };
+        delete uploads[id];
+        return { ...current, uploads };
+      });
+    };
+    /**
+     * Starts an upload for `id`, or returns the existing in-flight promise if one is already running.
+     * Uses {@link StreamChat.channel}(`channelCid`) → `messageComposer.attachmentManager.doUploadRequest`.
+     * Resolves with that result; rejects if the upload rejects (the record is removed from state either way).
+     */
+    this.upload = ({
+      id,
+      channelCid,
+      file
+    }) => {
+      const existing = this.inFlightUploads.get(id);
+      if (existing) return existing.promise;
+      let resolvePromise;
+      let rejectPromise;
+      const promise = new Promise((resolve, reject) => {
+        resolvePromise = resolve;
+        rejectPromise = reject;
+      });
+      const abortController = new AbortController();
+      this.inFlightUploads.set(id, { promise, abortController });
+      void (async () => {
+        const attachmentManager = this.resolveAttachmentManager(channelCid);
+        const trackProgress = attachmentManager.config.trackUploadProgress;
+        try {
+          this.upsertUpload({
+            uploadConfirmationPending: false,
+            id,
+            uploadProgress: trackProgress ? 0 : void 0
+          });
+          const onProgress = trackProgress ? (progress) => {
+            this.updateUpload({
+              id,
+              uploadProgress: progress,
+              // Only a number says anything about the flush, so a report without one leaves
+              // the flag alone: `undefined` means the transport cannot measure this upload,
+              // not that bytes were un-sent. Lowering it there would drop a UI that had
+              // already gone indeterminate back to a determinate one with nothing to show.
+              //
+              // The record is removed in the `finally` below, so a record that still exists
+              // while reporting 100% can only mean "flushed, awaiting the response".
+              ...typeof progress === "number" ? { uploadConfirmationPending: progress >= 100 } : {}
+            });
+          } : void 0;
+          const uploadRequestOptions = {
+            abortSignal: abortController.signal,
+            ...onProgress ? { onProgress } : {}
+          };
+          const response = await attachmentManager.doUploadRequest(
+            file,
+            uploadRequestOptions
+          );
+          resolvePromise(response);
+        } catch (error) {
+          rejectPromise(error);
+        } finally {
+          this.inFlightUploads.delete(id);
+          this.deleteUploadRecord(id);
+        }
+      })();
+      return promise;
+    };
+    this.upsertUpload = (record) => {
+      this.state.partialNext({
+        uploads: upsertById(this.uploads, record)
+      });
+    };
+    this.updateUpload = (record) => {
+      this.state.next((current) => {
+        const nextUploads = updateById(current.uploads, record);
+        if (!nextUploads) return current;
+        return { ...current, uploads: nextUploads };
+      });
+    };
+    this.state = new StateStore(initState());
+  }
+  resolveAttachmentManager(channelCid) {
+    const colon = channelCid.indexOf(":");
+    if (colon <= 0 || colon === channelCid.length - 1) {
+      throw new Error(`Invalid channelCid: ${channelCid}`);
+    }
+    const channelType = channelCid.slice(0, colon);
+    const channelId = channelCid.slice(colon + 1);
+    return this.client.channel(channelType, channelId).messageComposer.attachmentManager;
+  }
+  get uploads() {
+    return this.state.getLatestValue().uploads;
+  }
+};
+
 // src/messageComposer/middleware/attachmentManager/postUpload/uploadErrorHandler.ts
 var createUploadErrorHandlerMiddleware = (composer) => ({
   id: "stream-io/attachment-manager-middleware/upload-error",
@@ -2616,6 +2808,7 @@ var createUploadErrorHandlerMiddleware = (composer) => ({
       const { attachment, error } = state;
       if (!error) return forward();
       if (!attachment) return discard();
+      if (isUploadCancellation(error)) return forward();
       const reason = error instanceof Error ? error.message : "unknown error";
       composer.client.notifications.addError({
         message: "Error uploading attachment",
@@ -2640,7 +2833,7 @@ var AttachmentPostUploadMiddlewareExecutor = class extends MiddlewareExecutor {
     super();
     this.use([
       createUploadErrorHandlerMiddleware(composer),
-      createPostUploadAttachmentEnrichmentMiddleware()
+      createPostUploadAttachmentEnrichmentMiddleware(composer)
     ]);
   }
 };
@@ -3088,7 +3281,7 @@ function mergeWithDiff(target, source, customizer) {
 }
 
 // src/messageComposer/attachmentManager.ts
-var initState = ({
+var initState2 = ({
   message
 }) => ({
   attachments: (message?.attachments ?? [])?.filter(({ og_scrape_url }) => !og_scrape_url).map((att) => {
@@ -3116,13 +3309,14 @@ var _AttachmentManager = class _AttachmentManager {
         ...attachment,
         localMetadata: {
           ...attachment.localMetadata,
+          uploadConfirmationPending: false,
           uploadProgress: void 0,
           uploadState: "failed"
         }
       };
     };
     this.initState = ({ message } = {}) => {
-      this.state.next(initState({ message }));
+      this.state.next(initState2({ message }));
     };
     this.getSnapshot = () => {
       const state = this.state.getLatestValue();
@@ -3199,8 +3393,22 @@ var _AttachmentManager = class _AttachmentManager {
         this.state.partialNext({ attachments });
       }
     };
+    /**
+     * Releases a local preview URL the SDK minted, if it minted one.
+     *
+     * Only `blob:` URLs are ours to revoke: `toLocalUploadAttachment` puts a
+     * `URL.createObjectURL` result in `previewUri` for a `File`, but for a React Native
+     * `FileReference` it stores the caller's own native file URI, which must be left alone.
+     */
+    this.revokePreviewUri = (attachment) => {
+      const previewUri = attachment.localMetadata?.previewUri;
+      if (previewUri?.startsWith("blob:")) URL.revokeObjectURL?.(previewUri);
+    };
     this.removeAttachments = (localAttachmentIds) => {
       if (!localAttachmentIds.length) return;
+      const removedAttachments = this.attachments.filter(
+        (attachment) => localAttachmentIds.includes(attachment.localMetadata?.id)
+      );
       this.state.partialNext({
         attachments: this.attachments.filter(
           (attachment) => !localAttachmentIds.includes(attachment.localMetadata?.id)
@@ -3209,6 +3417,7 @@ var _AttachmentManager = class _AttachmentManager {
       for (const id of localAttachmentIds) {
         this.client.uploadManager.deleteUploadRecord(id);
       }
+      removedAttachments.forEach(this.revokePreviewUri);
     };
     this.getUploadConfigCheck = async (fileLike) => {
       const client = this.channel.getClient();
@@ -3360,21 +3569,27 @@ var _AttachmentManager = class _AttachmentManager {
           localMetadata: {
             ...attachment.localMetadata,
             uploadState: "failed",
-            uploadProgress: void 0
+            uploadProgress: void 0,
+            // `false`, not `undefined`: these updates go through `updateAttachment`, which merges
+            // via `mergeWith` — and that skips `undefined` source values, so `undefined` would
+            // leave a stale `true` in place.
+            uploadConfirmationPending: false
           }
         };
-        this.client.notifications.addError({
-          message: "Error uploading attachment",
-          origin: {
-            emitter: "AttachmentManager",
-            context: { attachment, failedAttachment }
-          },
-          options: {
-            type: "api:attachment:upload:failed",
-            metadata: { reason },
-            originalError: error instanceof Error ? error : void 0
-          }
-        });
+        if (!isUploadCancellation(error)) {
+          this.client.notifications.addError({
+            message: "Error uploading attachment",
+            origin: {
+              emitter: "AttachmentManager",
+              context: { attachment, failedAttachment }
+            },
+            options: {
+              type: "api:attachment:upload:failed",
+              metadata: { reason },
+              originalError: error instanceof Error ? error : void 0
+            }
+          });
+        }
         this.updateAttachment(failedAttachment);
         return failedAttachment;
       }
@@ -3387,7 +3602,9 @@ var _AttachmentManager = class _AttachmentManager {
         localMetadata: {
           ...attachment.localMetadata,
           uploadState: "finished",
-          uploadProgress: void 0
+          uploadProgress: void 0,
+          // See the note in the failure branch: `undefined` cannot clear through `mergeWith`.
+          uploadConfirmationPending: false
         }
       };
       const previewUri = uploadedAttachment.localMetadata.previewUri;
@@ -3436,7 +3653,9 @@ var _AttachmentManager = class _AttachmentManager {
             localMetadata: {
               ...attachment.localMetadata,
               uploadState: error ? "failed" : "finished",
-              uploadProgress: void 0
+              uploadProgress: void 0,
+              // See the note in `uploadAttachment`: `undefined` cannot clear through `mergeWith`.
+              uploadConfirmationPending: false
             }
           },
           error,
@@ -3461,7 +3680,7 @@ var _AttachmentManager = class _AttachmentManager {
       );
     };
     this.composer = composer;
-    this.state = new StateStore(initState({ message }));
+    this.state = new StateStore(initState2({ message }));
     this.attachmentsByIdGetterCache = { attachmentsById: {}, attachments: [] };
     this.preUploadMiddlewareExecutor = new AttachmentPreUploadMiddlewareExecutor({
       composer
@@ -3566,7 +3785,8 @@ var _AttachmentManager = class _AttachmentManager {
         localMetadata: {
           ...attachment.localMetadata,
           uploadState: "uploading",
-          uploadProgress: this.config.trackUploadProgress ? 0 : void 0
+          uploadProgress: this.config.trackUploadProgress ? 0 : void 0,
+          uploadConfirmationPending: false
         }
       }
     ]);
@@ -3579,7 +3799,8 @@ var _AttachmentManager = class _AttachmentManager {
           localMetadata: {
             ...attachment.localMetadata,
             uploadState: "uploading",
-            uploadProgress: nextUpload.uploadProgress
+            uploadProgress: nextUpload.uploadProgress,
+            uploadConfirmationPending: nextUpload.uploadConfirmationPending
           }
         });
       }
@@ -3633,6 +3854,50 @@ var localAttachmentToAttachment = (localAttachment) => {
   const { localMetadata, ...attachment } = localAttachment;
   return attachment;
 };
+var composeWithPendingUploads = ({
+  composer,
+  state
+}) => {
+  const composerIsKeptAsDraft = !!composer.pollId;
+  const relevantAttachments = composer.attachmentManager.attachments.filter(
+    (attachment) => isFinishedUpload(attachment) || !composerIsKeptAsDraft && isPendingUpload(attachment)
+  );
+  const localAttachments = (state.localMessage.attachments ?? []).concat(
+    relevantAttachments.map(
+      (attachment) => isPendingUpload(attachment) ? attachment : localAttachmentToAttachment(attachment)
+    )
+  );
+  const messageAttachments = (state.message.attachments ?? []).concat(
+    relevantAttachments.filter(isFinishedUpload).map(localAttachmentToAttachment)
+  );
+  if (!localAttachments.length && !messageAttachments.length) return state;
+  return {
+    ...state,
+    localMessage: localAttachments.length ? {
+      ...state.localMessage,
+      attachments: localAttachments
+    } : state.localMessage,
+    message: messageAttachments.length ? {
+      ...state.message,
+      attachments: messageAttachments
+    } : 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: {
@@ -3849,7 +4114,7 @@ var getInitialMentions = (message) => {
 };
 var isSameMentionEntity = (first, second) => first.id === second.id && first.mentionType === second.mentionType;
 var getMentionsFromState = (state) => state.mentions ?? state.mentionedUsers.map(userResponseToMentionEntity);
-var initState2 = ({
+var initState3 = ({
   composer,
   message
 }) => {
@@ -3878,7 +4143,7 @@ var initState2 = ({
 var TextComposer = class {
   constructor({ composer, message }) {
     this.initState = ({ message } = {}) => {
-      this.state.next(initState2({ composer: this.composer, message }));
+      this.state.next(initState3({ composer: this.composer, message }));
     };
     this.getSnapshot = (state = this.state.getLatestValue()) => state;
     this.restoreSnapshot = (snapshot) => {
@@ -4071,7 +4336,7 @@ var TextComposer = class {
       this.commitState(output.state);
     };
     this.composer = composer;
-    this.state = new StateStore(initState2({ composer, message }));
+    this.state = new StateStore(initState3({ composer, message }));
     this.middlewareExecutor = new TextComposerMiddlewareExecutor({ composer });
   }
   get channel() {
@@ -4221,13 +4486,41 @@ function isErrorResponse(res) {
 
 // src/search/BaseSearchSource.ts
 var DEFAULT_SEARCH_SOURCE_OPTIONS = {
-  debounceMs: 300,
   pageSize: 10,
   allowEmptySearchString: false,
   resetOnNewSearchQuery: true
 };
+var resolveDebounceOptions = ({
+  debounceMs,
+  shortQueryDebounceMs,
+  longQueryDebounceMs,
+  shortQueryMaxLength
+}) => ({
+  shortQueryDebounceMs: shortQueryDebounceMs ?? debounceMs ?? 500,
+  longQueryDebounceMs: longQueryDebounceMs ?? debounceMs ?? 300,
+  shortQueryMaxLength: shortQueryMaxLength ?? 2
+});
 var BaseSearchSourceBase = class {
   constructor(options) {
+    this.setDebounceOptions = (options = {}) => {
+      const resolved = resolveDebounceOptions(options);
+      this.shortQueryDebounceMs = resolved.shortQueryDebounceMs;
+      this.longQueryDebounceMs = resolved.longQueryDebounceMs;
+      this.shortQueryMaxLength = resolved.shortQueryMaxLength;
+      this.searchDebounced = debounce(
+        this.executeQuery.bind(this),
+        (searchString) => this.getDebounceMs(searchString)
+      );
+    };
+    /**
+     * Short queries match too much and are slow server-side, so they get a longer debounce.
+     * Resolved per call, which is what lets the interval switch as the user keeps typing.
+     */
+    this.getDebounceMs = (searchString) => {
+      const { length } = searchString ?? this.searchQuery;
+      return length <= this.shortQueryMaxLength ? this.shortQueryDebounceMs : this.longQueryDebounceMs;
+    };
+    this.search = (searchQuery) => this.searchDebounced(searchQuery);
     this.activate = () => {
       if (this.isActive) return;
       this.state.partialNext({ isActive: true });
@@ -4239,7 +4532,7 @@ var BaseSearchSourceBase = class {
     this.canExecuteQuery = (newSearchString) => {
       const hasNewSearchQuery = typeof newSearchString !== "undefined";
       const searchString = newSearchString ?? this.searchQuery;
-      return !!(this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery) && (this.allowEmptySearchString || searchString));
+      return !!(this.isActive && this.canDispatchQuery(hasNewSearchQuery) && (this.allowEmptySearchString || searchString));
     };
     const { pageSize, allowEmptySearchString, resetOnNewSearchQuery } = {
       ...DEFAULT_SEARCH_SOURCE_OPTIONS,
@@ -4249,6 +4542,14 @@ var BaseSearchSourceBase = class {
     this.allowEmptySearchString = allowEmptySearchString;
     this.resetOnNewSearchQuery = resetOnNewSearchQuery;
     this.state = new StateStore(this.initialState);
+    this.setDebounceOptions(options ?? {});
+  }
+  /**
+   * A new search query preempts an in-flight one; pagination waits for it to finish
+   * and needs a next page to fetch.
+   */
+  canDispatchQuery(hasNewSearchQuery) {
+    return hasNewSearchQuery || !this.isLoading && this.hasNext;
   }
   get lastQueryError() {
     return this.state.getLatestValue().lastQueryError;
@@ -4343,21 +4644,30 @@ var BaseSearchSourceBase = class {
   }
 };
 var BaseSearchSource = class extends BaseSearchSourceBase {
-  constructor(options) {
-    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
-    super(options);
-    this.setDebounceOptions = ({ debounceMs }) => {
-      this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-    };
-    this.search = (searchQuery) => this.searchDebounced(searchQuery);
-    this.setDebounceOptions({ debounceMs });
+  constructor() {
+    super(...arguments);
+    /** Aborts the in-flight request, if any, once a newer query is dispatched. */
+    this.queryAbortController = null;
+  }
+  /** Aborts the in-flight request, if any. Returns true when one was aborted. */
+  abortInFlightQuery() {
+    if (!this.queryAbortController) return false;
+    this.queryAbortController.abort();
+    this.queryAbortController = null;
+    return true;
+  }
+  resetState() {
+    this.abortInFlightQuery();
+    super.resetState();
   }
   async executeQuery(newSearchString) {
     if (!this.canExecuteQuery(newSearchString)) return;
+    this.abortInFlightQuery();
+    const { signal } = this.queryAbortController = new AbortController();
     const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
     let stateUpdate = {};
     try {
-      const results = await this.query(searchString);
+      const results = await this.query(searchString, { signal });
       if (!results) return;
       const { items } = results;
       stateUpdate = this.updatePaginationStateFromQuery(results);
@@ -4368,23 +4678,19 @@ var BaseSearchSource = class extends BaseSearchSourceBase {
         stateUpdate.hasNext = false;
       }
     } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+      if (!signal.aborted) {
+        this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+      }
     }
   }
   cancelScheduledQuery() {
     this.searchDebounced.cancel();
+    if (this.abortInFlightQuery() && this.isLoading) {
+      this.state.partialNext({ isLoading: false });
+    }
   }
 };
 var BaseSearchSourceSync = class extends BaseSearchSourceBase {
-  constructor(options) {
-    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
-    super(options);
-    this.setDebounceOptions = ({ debounceMs }) => {
-      this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-    };
-    this.search = (searchQuery) => this.searchDebounced(searchQuery);
-    this.setDebounceOptions({ debounceMs });
-  }
   executeQuery(newSearchString) {
     if (!this.canExecuteQuery(newSearchString)) return;
     const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
@@ -4680,13 +4986,13 @@ var UserGroupPaginator = class extends BasePaginator {
 // src/search/ChannelMemberSearchSource.ts
 var ChannelMemberSearchSource = class extends BaseSearchSource {
   constructor(channel, options, filterBuilderOptions = {}) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super({ ...restOptions, allowEmptySearchString: true });
     this.type = "members";
-    this.canExecuteQuery = (newSearchString) => {
-      const hasNewSearchQuery = typeof newSearchString !== "undefined";
-      return this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery);
-    };
     this.channel = channel;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder({
       initialFilterConfig: {
         default: {
@@ -4702,7 +5008,7 @@ var ChannelMemberSearchSource = class extends BaseSearchSource {
       ...filterBuilderOptions
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: this.filters,
       context: {
@@ -4711,7 +5017,12 @@ var ChannelMemberSearchSource = class extends BaseSearchSource {
     });
     const sort = this.sort ?? [];
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const { members } = await this.channel.queryMembers(filters ?? {}, sort, options);
+    const { members } = await this.channel.queryMembers(
+      filters ?? {},
+      sort,
+      options,
+      queryOptions
+    );
     return { items: members };
   }
   filterQueryResults(items) {
@@ -4826,9 +5137,13 @@ var SearchController = class {
 // src/search/UserSearchSource.ts
 var UserSearchSource = class extends BaseSearchSource {
   constructor(client, options, filterBuilderOptions = {}) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super(restOptions);
     this.type = "users";
     this.client = client;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder({
       initialFilterConfig: {
         $or: {
@@ -4844,7 +5159,7 @@ var UserSearchSource = class extends BaseSearchSource {
       ...filterBuilderOptions
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: this.filters,
       context: { searchQuery }
@@ -4857,7 +5172,7 @@ var UserSearchSource = class extends BaseSearchSource {
       sort = { id: 1, ...this.sort };
     }
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const { users } = await this.client.queryUsers(filters, sort, options);
+    const { users } = await this.client.queryUsers(filters, sort, options, queryOptions);
     return { items: users };
   }
   filterQueryResults(items) {
@@ -4868,9 +5183,13 @@ var UserSearchSource = class extends BaseSearchSource {
 // src/search/ChannelSearchSource.ts
 var ChannelSearchSource = class extends BaseSearchSource {
   constructor(client, options, filterBuilderOptions = {}) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super(restOptions);
     this.type = "channels";
     this.client = client;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder({
       ...filterBuilderOptions,
       initialFilterConfig: {
@@ -4882,7 +5201,7 @@ var ChannelSearchSource = class extends BaseSearchSource {
       }
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: {
         ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
@@ -4892,7 +5211,7 @@ var ChannelSearchSource = class extends BaseSearchSource {
     });
     const sort = this.sort ?? {};
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const items = await this.client.queryChannels(filters, sort, options);
+    const items = await this.client.queryChannels(filters, sort, options, queryOptions);
     return { items };
   }
   filterQueryResults(items) {
@@ -4903,9 +5222,24 @@ var ChannelSearchSource = class extends BaseSearchSource {
 // src/search/MessageSearchSource.ts
 var MessageSearchSource = class extends BaseSearchSource {
   constructor(client, options, filterBuilderOptions) {
-    super(options);
+    const {
+      messageSearchChannelFilters,
+      messageSearchFilters,
+      messageSearchSort,
+      channelQueryFilters,
+      channelQuerySort,
+      channelQueryOptions,
+      ...restOptions
+    } = options || {};
+    super(restOptions);
     this.type = "messages";
     this.client = client;
+    this.messageSearchChannelFilters = messageSearchChannelFilters;
+    this.messageSearchFilters = messageSearchFilters;
+    this.messageSearchSort = messageSearchSort;
+    this.channelQueryFilters = channelQueryFilters;
+    this.channelQuerySort = channelQuerySort;
+    this.channelQueryOptions = channelQueryOptions;
     this.messageSearchChannelFilterBuilder = new FilterBuilder(filterBuilderOptions?.messageSearchChannel);
     this.messageSearchFilterBuilder = new FilterBuilder({
       ...filterBuilderOptions?.messageSearch,
@@ -4928,7 +5262,7 @@ var MessageSearchSource = class extends BaseSearchSource {
       }
     });
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     if (!this.client.userID || this.next === null) return { items: [] };
     const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
       baseFilters: {
@@ -4956,9 +5290,11 @@ var MessageSearchSource = class extends BaseSearchSource {
     const { next, results } = await this.client.search(
       channelFilters,
       messageFilters,
-      options
+      options,
+      queryOptions
     );
     const items = results.map(({ message }) => message);
+    if (queryOptions.signal?.aborted) return { items, next };
     const cids = Array.from(
       items.reduce((acc, message) => {
         if (message.cid && !this.client.activeChannels[message.cid]) acc.add(message.cid);
@@ -4976,7 +5312,8 @@ var MessageSearchSource = class extends BaseSearchSource {
           last_message_at: -1,
           ...this.channelQuerySort
         },
-        this.channelQueryOptions
+        this.channelQueryOptions,
+        queryOptions
       );
     }
     return { items, next };
@@ -5701,6 +6038,13 @@ 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 }) {
@@ -6270,13 +6614,18 @@ var MentionsSearchSource = class extends BaseSearchSource {
   constructor(channel, options) {
     const {
       mentionAllAppUsers,
+      memberFilters,
+      memberSort,
+      searchOptions,
       suggestionFactoryMappers,
       textComposerText,
       transliterate,
       trigger,
+      userFilters,
+      userSort,
       ...restOptions
     } = options || {};
-    super(restOptions);
+    super({ ...restOptions, allowEmptySearchString: true });
     this.type = "mentions";
     this.normalizeSearchValue = (value) => this.transliterate(removeDiacritics(value)).toLowerCase();
     this.matchesSearchQuery = (value, searchQuery) => {
@@ -6314,10 +6663,6 @@ var MentionsSearchSource = class extends BaseSearchSource {
     this.toHereMentionSuggestion = (searchToken = this.searchQuery) => this.mapMentionSuggestion("here", "here", searchToken);
     this.toRoleMentionSuggestion = (role, searchToken = this.searchQuery) => this.mapMentionSuggestion("role", role, searchToken);
     this.toUserGroupMentionSuggestion = (userGroup, searchToken = this.searchQuery) => this.mapMentionSuggestion("user_group", userGroup, searchToken);
-    this.canExecuteQuery = (newSearchString) => {
-      const hasNewSearchQuery = typeof newSearchString !== "undefined";
-      return this.isActive && !this.isLoading && (hasNewSearchQuery || this.hasNext);
-    };
     this.transliterate = (text) => text;
     this.getMembersAndWatchers = () => {
       const memberUsers = Object.values(this.channel.state.members ?? {}).map(
@@ -6337,10 +6682,10 @@ var MentionsSearchSource = class extends BaseSearchSource {
       ...this.isMentionTypeAllowed("channel") ? [this.toChannelMentionSuggestion(searchQuery)] : [],
       ...this.isMentionTypeAllowed("here") ? [this.toHereMentionSuggestion(searchQuery)] : []
     ].filter(({ name }) => this.matchesPrefixSearchQuery(name, searchQuery));
-    this.getRoleMentionSuggestions = async (query) => {
+    this.getRoleMentionSuggestions = async (query, queryOptions = {}) => {
       if (!this.isMentionTypeAllowed("role")) return [];
       if (!query) return [];
-      const { roles } = await this.client.searchRoles({ query });
+      const { roles } = await this.client.searchRoles({ query }, queryOptions);
       return [...roles?.map((role) => role.name) ?? []].sort((left, right) => left.localeCompare(right)).map((role) => this.toRoleMentionSuggestion(role, query));
     };
     this.searchMembersLocally = (searchQuery) => {
@@ -6402,20 +6747,25 @@ var MentionsSearchSource = class extends BaseSearchSource {
         options: { ...this.searchOptions, limit: this.pageSize, offset }
       };
     };
-    this.queryUsers = async (searchQuery, offset = 0) => {
+    this.queryUsers = async (searchQuery, offset = 0, queryOptions = {}) => {
       const { filters, sort, options } = this.prepareQueryUsersParams(searchQuery, offset);
-      const { users } = await this.client.queryUsers(filters, sort, options);
+      const { users } = await this.client.queryUsers(filters, sort, options, queryOptions);
       return users;
     };
-    this.queryMembers = async (searchQuery, offset = 0) => {
+    this.queryMembers = async (searchQuery, offset = 0, queryOptions = {}) => {
       const { filters, sort, options } = this.prepareQueryMembersParams(
         searchQuery,
         offset
       );
-      const response = await this.channel.queryMembers(filters, sort, options);
+      const response = await this.channel.queryMembers(
+        filters,
+        sort,
+        options,
+        queryOptions
+      );
       return response.members.map((member) => member.user);
     };
-    this.getUserSuggestionsPage = async (searchQuery, userOffset = 0) => {
+    this.getUserSuggestionsPage = async (searchQuery, userOffset = 0, queryOptions = {}) => {
       if (!this.isMentionTypeAllowed("user")) {
         return {
           items: [],
@@ -6425,7 +6775,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
       let users;
       const shouldSearchLocally = this.allMembersLoadedWithInitialChannelQuery || !searchQuery;
       if (this.config.mentionAllAppUsers) {
-        users = await this.queryUsers(searchQuery, userOffset);
+        users = await this.queryUsers(searchQuery, userOffset, queryOptions);
       } else if (shouldSearchLocally) {
         const localUsers = this.searchMembersLocally(searchQuery);
         const items2 = localUsers.slice(userOffset, userOffset + this.pageSize).map((user) => this.toUserSuggestion(user, searchQuery));
@@ -6434,7 +6784,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
           nextOffset: localUsers.length > userOffset + this.pageSize ? userOffset + items2.length : void 0
         };
       } else {
-        users = await this.queryMembers(searchQuery, userOffset);
+        users = await this.queryMembers(searchQuery, userOffset, queryOptions);
       }
       const items = users.map((user) => this.toUserSuggestion(user, searchQuery));
       return {
@@ -6451,7 +6801,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
         name_gt: lastItem.name
       });
     };
-    this.getUserGroupSuggestionsPage = async (searchQuery, cursor) => {
+    this.getUserGroupSuggestionsPage = async (searchQuery, cursor, queryOptions = {}) => {
       if (!this.isMentionTypeAllowed("user_group")) {
         return {
           items: [],
@@ -6473,7 +6823,7 @@ var MentionsSearchSource = class extends BaseSearchSource {
         ...userGroupCursor?.id_gt ? { id_gt: userGroupCursor.id_gt } : {},
         ...userGroupCursor?.name_gt ? { name_gt: userGroupCursor.name_gt } : {}
       };
-      const { user_groups } = await this.client.searchUserGroups(options);
+      const { user_groups } = await this.client.searchUserGroups(options, queryOptions);
       return {
         items: user_groups.map(
           (userGroup) => this.toUserGroupMentionSuggestion(userGroup, searchQuery)
@@ -6483,6 +6833,11 @@ var MentionsSearchSource = class extends BaseSearchSource {
     };
     this.client = channel.getClient();
     this.channel = channel;
+    this.userFilters = userFilters;
+    this.userSort = userSort;
+    this.memberFilters = memberFilters;
+    this.memberSort = memberSort;
+    this.searchOptions = searchOptions;
     this.config = {
       mentionAllAppUsers,
       suggestionFactoryMappers,
@@ -6515,16 +6870,21 @@ var MentionsSearchSource = class extends BaseSearchSource {
       offset: (this.offset ?? 0) + userPaginationState.itemCount
     };
   }
-  async query(searchQuery) {
+  async query(searchQuery, queryOptions = {}) {
     const userOffset = this.offset ?? 0;
     const isFirstPage = userOffset === 0 && typeof this.userGroupCursor === "undefined";
     const previousUserPaginationState = this.latestUserPaginationState;
     const previousUserGroupCursor = this.userGroupCursor;
     const [userResultsState, userGroupResultsState, roleSuggestionsState] = await Promise.allSettled([
-      this.getUserSuggestionsPage(searchQuery, userOffset),
-      this.getUserGroupSuggestionsPage(searchQuery, previousUserGroupCursor),
-      isFirstPage ? this.getRoleMentionSuggestions(searchQuery) : Promise.resolve([])
+      this.getUserSuggestionsPage(searchQuery, userOffset, queryOptions),
+      this.getUserGroupSuggestionsPage(
+        searchQuery,
+        previousUserGroupCursor,
+        queryOptions
+      ),
+      isFirstPage ? this.getRoleMentionSuggestions(searchQuery, queryOptions) : Promise.resolve([])
     ]);
+    if (queryOptions.signal?.aborted) return { items: [] };
     const userResults = userResultsState.status === "fulfilled" ? userResultsState.value : {
       items: [],
       nextOffset: isFirstPage ? void 0 : previousUserPaginationState?.nextOffset
@@ -6799,7 +7159,7 @@ var DEFAULT_COMPOSER_CONFIG = {
 };
 
 // src/messageComposer/CustomDataManager.ts
-var initState3 = (options) => {
+var initState4 = (options) => {
   if (!options)
     return { message: {}, custom: {} };
   return { message: {}, custom: {} };
@@ -6808,14 +7168,14 @@ var CustomDataManager = class {
   constructor({ composer, message }) {
     this.isMessageDataEqual = (nextState, previousState) => JSON.stringify(nextState.message) === JSON.stringify(previousState?.message);
     this.initState = ({ message } = {}) => {
-      this.state.next(initState3({ composer: this.composer, message }));
+      this.state.next(initState4({ composer: this.composer, message }));
     };
     this.getSnapshot = () => this.state.getLatestValue();
     this.restoreSnapshot = (snapshot) => {
       this.state.next(snapshot);
     };
     this.composer = composer;
-    this.state = new StateStore(initState3({ composer, message }));
+    this.state = new StateStore(initState4({ composer, message }));
   }
   get customMessageData() {
     return this.state.getLatestValue().message;
@@ -6851,7 +7211,7 @@ var LinkPreviewStatus = /* @__PURE__ */ ((LinkPreviewStatus2) => {
   return LinkPreviewStatus2;
 })(LinkPreviewStatus || {});
 var linkPreviewArrayToMap = (linkPreviews) => new Map(linkPreviews.map((linkPreview) => [linkPreview.og_scrape_url, linkPreview]));
-var initState4 = ({
+var initState5 = ({
   message
 }) => message ? {
   previews: message.attachments?.reduce((acc, attachment) => {
@@ -6870,7 +7230,7 @@ var _LinkPreviewsManager = class _LinkPreviewsManager {
     this.shouldDiscardEnrichQueries = false;
     this.initState = ({ message } = {}) => {
       this.cancelURLEnrichment();
-      this.state.next(initState4({ message: this.enabled ? message : void 0 }));
+      this.state.next(initState5({ message: this.enabled ? message : void 0 }));
     };
     this.getSnapshot = () => this.state.getLatestValue();
     this.restoreSnapshot = (snapshot) => {
@@ -6973,7 +7333,7 @@ var _LinkPreviewsManager = class _LinkPreviewsManager {
     };
     this.composer = composer;
     this.state = new StateStore(
-      initState4({ message: this.enabled ? message : void 0 })
+      initState5({ message: this.enabled ? message : void 0 })
     );
     this.findAndEnrichUrls = debounce(
       this._findAndEnrichUrls.bind(this),
@@ -7061,7 +7421,7 @@ var LinkPreviewsManager = _LinkPreviewsManager;
 
 // src/messageComposer/LocationComposer.ts
 var MIN_LIVE_LOCATION_SHARE_DURATION = 60 * 1e3;
-var initState5 = ({
+var initState6 = ({
   message
 }) => ({
   location: message?.shared_location ?? null
@@ -7069,7 +7429,7 @@ var initState5 = ({
 var LocationComposer = class {
   constructor({ composer, message }) {
     this.initState = ({ message } = {}) => {
-      this.state.next(initState5({ message }));
+      this.state.next(initState6({ message }));
     };
     this.getSnapshot = () => this.state.getLatestValue();
     this.restoreSnapshot = (snapshot) => {
@@ -7087,7 +7447,7 @@ var LocationComposer = class {
       });
     };
     this.composer = composer;
-    this.state = new StateStore(initState5({ message }));
+    this.state = new StateStore(initState6({ message }));
     this._deviceId = this.config.getDeviceId();
   }
   get config() {
@@ -7808,7 +8168,7 @@ var initEditingAuditState = (composition) => {
     }
   };
 };
-var initState6 = (composition) => {
+var initState7 = (composition) => {
   if (!composition) {
     return {
       draftId: null,
@@ -7895,7 +8255,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
       this.textComposer.initState({ message });
       this.pollComposer.initState();
       this.customDataManager.initState({ message });
-      this.state.next(initState6(composition));
+      this.state.next(initState7(composition));
     };
     this.initStateFromChannelResponse = (channelApiResponse) => {
       if (this.channel.cid !== channelApiResponse.channel.cid) {
@@ -8361,7 +8721,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     this.editingAuditState = new StateStore(
       this.initEditingAuditState(composition)
     );
-    this.state = new StateStore(initState6(composition));
+    this.state = new StateStore(initState7(composition));
     this.compositionMiddlewareExecutor = new MessageComposerMiddlewareExecutor({
       composer: this
     });
@@ -8440,8 +8800,32 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     const currentCommand = this.textComposer.command;
     return !currentCommand || this.validateCommandSendability(currentCommand).ready;
   }
+  /**
+   * Whether the installed composition middleware composes messages whose uploads are still in
+   * flight — see `MessageCompositionMiddleware.allowsPendingUploads`.
+   *
+   * 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.
+   *
+   * **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.
+   */
+  get allowsPendingUploads() {
+    return this.compositionMiddlewareExecutor.installedMiddleware.some(
+      (middleware) => middleware.allowsPendingUploads
+    );
+  }
   get hasSendableData() {
-    return this.isCommandSendable && !!(!this.attachmentManager.uploadsInProgressCount && (!this.textComposer.textIsEmpty || this.attachmentManager.successfulUploadsCount > 0) || this.pollId || !!this.locationComposer.validLocation);
+    if (!this.isCommandSendable) return false;
+    if (this.allowsPendingUploads) {
+      const hasSendableAttachment = this.attachmentManager.attachments.some(
+        (attachment) => isFinishedUpload(attachment) || isPendingUpload(attachment)
+      );
+      return !!(!this.textComposer.textIsEmpty || hasSendableAttachment || this.pollId || this.locationComposer.validLocation);
+    }
+    return !!(!this.attachmentManager.uploadsInProgressCount && (!this.textComposer.textIsEmpty || this.attachmentManager.successfulUploadsCount > 0) || this.pollId || !!this.locationComposer.validLocation);
   }
   get compositionIsEmpty() {
     return !this.quotedMessage && this.contentIsEmpty;
@@ -9068,14 +9452,16 @@ var Channel = class {
    *
    * @return {Promise<SendMessageAPIResponse>} The Server Response
    */
-  async _sendMessage(message, options) {
-    return await this.getClient().post(
-      this._channelURL() + "/message",
-      {
-        message,
-        ...options
-      }
-    );
+  async _sendMessage(rawMessage, options) {
+    const client = this.getClient();
+    const message = sanitizeOutgoingAttachments({
+      client,
+      message: rawMessage
+    });
+    return await client.post(this._channelURL() + "/message", {
+      message,
+      ...options
+    });
   }
   async sendMessage(message, options) {
     try {
@@ -9200,10 +9586,11 @@ var Channel = class {
    * @param {MemberSort} [sort] Sort options, for instance [{created_at: -1}].
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{name: -1}, {created_at: 1}]
    * @param {{ limit?: number; offset?: number }} [options] Option object, {limit: 10, offset:10}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<ChannelMemberAPIResponse>} Query Members response
    */
-  async queryMembers(filterConditions, sort = [], options = {}) {
+  async queryMembers(filterConditions, sort = [], options = {}, requestOptions = {}) {
     let id;
     const type = this.type;
     let members;
@@ -9223,7 +9610,8 @@ var Channel = class {
           filter_conditions: filterConditions,
           ...options
         }
-      }
+      },
+      requestOptions
     );
   }
   /**
@@ -10524,6 +10912,7 @@ var Channel = class {
       // delivery-report network sync below is skipped for it.
       case "message.read_locally":
       case "message.read":
+        if (event.thread) break;
         if (event.user?.id && event.created_at) {
           const previousReadState = channelState.read[event.user.id];
           channelState.read[event.user.id] = {
@@ -10973,7 +11362,7 @@ var ClientState = class {
 import WebSocket from "isomorphic-ws";
 
 // src/insights.ts
-import axios from "axios";
+import axios2 from "axios";
 var InsightMetrics = class {
   constructor() {
     this.connectionStartTimestamp = null;
@@ -10986,7 +11375,7 @@ var postInsights = async (insightType, insights) => {
   const maxAttempts = 3;
   for (let i = 0; i < maxAttempts; i++) {
     try {
-      await axios.post(
+      await axios2.post(
         `https://chat-insights.getstream.io/insights/${insightType}`,
         insights
       );
@@ -11494,131 +11883,6 @@ var StableWSConnection = class {
   }
 };
 
-// src/uploadManager.ts
-var initState7 = () => ({ uploads: {} });
-var upsertById = (uploads, record) => ({
-  ...uploads,
-  [record.id]: { ...uploads[record.id], ...record }
-});
-var updateById = (uploads, record) => {
-  if (!(record.id in uploads)) return null;
-  const current = uploads[record.id];
-  return { ...uploads, [record.id]: { ...current, ...record } };
-};
-var UploadManager = class {
-  constructor(client) {
-    this.client = client;
-    this.inFlightUploads = /* @__PURE__ */ new Map();
-    this.getUpload = (id) => this.uploads[id];
-    /**
-     * Clears all upload records.
-     * Invoked when the user disconnects so a later session does not inherit stale upload state.
-     * Aborts every in-flight upload request via its `UploadRequestOptions.abortSignal`.
-     */
-    this.reset = () => {
-      for (const { abortController } of this.inFlightUploads.values()) {
-        abortController.abort();
-      }
-      this.inFlightUploads.clear();
-      this.state.next(initState7());
-    };
-    /**
-     * Removes the upload record for `id` if present.
-     * If an upload is still in progress, aborts its `UploadRequestOptions.abortSignal`.
-     */
-    this.deleteUploadRecord = (id) => {
-      const flight = this.inFlightUploads.get(id);
-      if (flight) {
-        this.inFlightUploads.delete(id);
-        flight.abortController.abort();
-      }
-      this.state.next((current) => {
-        if (!(id in current.uploads)) return current;
-        const uploads = { ...current.uploads };
-        delete uploads[id];
-        return { ...current, uploads };
-      });
-    };
-    /**
-     * Starts an upload for `id`, or returns the existing in-flight promise if one is already running.
-     * Uses {@link StreamChat.channel}(`channelCid`) → `messageComposer.attachmentManager.doUploadRequest`.
-     * Resolves with that result; rejects if the upload rejects (the record is removed from state either way).
-     */
-    this.upload = ({
-      id,
-      channelCid,
-      file
-    }) => {
-      const existing = this.inFlightUploads.get(id);
-      if (existing) return existing.promise;
-      let resolvePromise;
-      let rejectPromise;
-      const promise = new Promise((resolve, reject) => {
-        resolvePromise = resolve;
-        rejectPromise = reject;
-      });
-      const abortController = new AbortController();
-      this.inFlightUploads.set(id, { promise, abortController });
-      void (async () => {
-        const attachmentManager = this.resolveAttachmentManager(channelCid);
-        const trackProgress = attachmentManager.config.trackUploadProgress;
-        try {
-          this.upsertUpload({
-            id,
-            uploadProgress: trackProgress ? 0 : void 0
-          });
-          const onProgress = trackProgress ? (progress) => {
-            this.updateUpload({
-              id,
-              uploadProgress: progress
-            });
-          } : void 0;
-          const uploadRequestOptions = {
-            abortSignal: abortController.signal,
-            ...onProgress ? { onProgress } : {}
-          };
-          const response = await attachmentManager.doUploadRequest(
-            file,
-            uploadRequestOptions
-          );
-          resolvePromise(response);
-        } catch (error) {
-          rejectPromise(error);
-        } finally {
-          this.inFlightUploads.delete(id);
-          this.deleteUploadRecord(id);
-        }
-      })();
-      return promise;
-    };
-    this.upsertUpload = (record) => {
-      this.state.partialNext({
-        uploads: upsertById(this.uploads, record)
-      });
-    };
-    this.updateUpload = (record) => {
-      this.state.next((current) => {
-        const nextUploads = updateById(current.uploads, record);
-        if (!nextUploads) return current;
-        return { ...current, uploads: nextUploads };
-      });
-    };
-    this.state = new StateStore(initState7());
-  }
-  resolveAttachmentManager(channelCid) {
-    const colon = channelCid.indexOf(":");
-    if (colon <= 0 || colon === channelCid.length - 1) {
-      throw new Error(`Invalid channelCid: ${channelCid}`);
-    }
-    const channelType = channelCid.slice(0, colon);
-    const channelId = channelCid.slice(colon + 1);
-    return this.client.channel(channelType, channelId).messageComposer.attachmentManager;
-  }
-  get uploads() {
-    return this.state.getLatestValue().uploads;
-  }
-};
-
 // src/signing.ts
 var import_jsonwebtoken = __toESM(require_jsonwebtoken());
 var import_crypto = __toESM(require_crypto());
@@ -11877,7 +12141,7 @@ var TokenManager = class {
 };
 
 // src/connection_fallback.ts
-import axios2 from "axios";
+import axios3 from "axios";
 var WSConnectionFallback = class {
   constructor({ client }) {
     /** @private */
@@ -11896,7 +12160,7 @@ var WSConnectionFallback = class {
     /** @private */
     this._req = async (params, config, retry) => {
       if (!this.cancelToken && !params.close) {
-        this.cancelToken = axios2.CancelToken.source();
+        this.cancelToken = axios3.CancelToken.source();
       }
       try {
         const res = await this.client.doAxiosRequest(
@@ -11932,7 +12196,7 @@ var WSConnectionFallback = class {
             }
           }
         } catch (error) {
-          if (axios2.isCancel(error)) {
+          if (axios3.isCancel(error)) {
             this._log(`_poll() - axios canceled request`);
             return;
           }
@@ -14355,6 +14619,7 @@ var StreamChat = class _StreamChat {
         return this.handleResponse(response);
       } catch (e) {
         e.client_request_id = requestConfig.headers?.["x-client-request-id"];
+        if (axios4.isCancel(e)) throw e;
         this._logApiError(type, url, e);
         this.consecutiveFailures += 1;
         if (e.response) {
@@ -14666,7 +14931,7 @@ var StreamChat = class _StreamChat {
         return this.userAgent;
       }
       if (!this.cachedUserAgent) {
-        const version = "9.50.3";
+        const version = "9.52.0";
         const { name: sdkName, version: sdkVersion } = this.sdkIdentifier ?? {};
         const { name: appName, version: appVersion } = this.appIdentifier ?? {};
         const { os, model: deviceModel } = this.deviceIdentifier ?? {};
@@ -14734,7 +14999,7 @@ var StreamChat = class _StreamChat {
         keepAliveMsecs: 3e3
       });
     }
-    this.axiosInstance = axios3.create(this.options);
+    this.axiosInstance = axios4.create(this.options);
     this.setBaseURL(this.options.baseURL || "https://chat.stream-io-api.com");
     if (typeof process !== "undefined" && "env" in process && process.env.STREAM_LOCAL_TEST_RUN) {
       this.setBaseURL("http://localhost:3030");
@@ -15042,14 +15307,14 @@ var StreamChat = class _StreamChat {
       error
     });
   }
-  get(url, params) {
-    return this.doAxiosRequest("get", url, null, { params });
+  get(url, params, config) {
+    return this.doAxiosRequest("get", url, null, { params, config });
   }
   put(url, data) {
     return this.doAxiosRequest("put", url, data);
   }
-  post(url, data) {
-    return this.doAxiosRequest("post", url, data);
+  post(url, data, config) {
+    return this.doAxiosRequest("post", url, data, { config });
   }
   patch(url, data) {
     return this.doAxiosRequest("patch", url, data);
@@ -15244,10 +15509,11 @@ var StreamChat = class _StreamChat {
    * @param {UserSort} sort Sort options, for instance [{last_active: -1}].
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_active: -1}, {created_at: 1}]
    * @param {UserOptions} options Option object, {presence: true}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<{ users: Array<UserResponse> }>} User Query Response
    */
-  async queryUsers(filterConditions, sort = [], options = {}) {
+  async queryUsers(filterConditions, sort = [], options = {}, requestOptions = {}) {
     const defaultOptions = {
       presence: false
     };
@@ -15264,7 +15530,8 @@ var StreamChat = class _StreamChat {
           ...defaultOptions,
           ...options
         }
-      }
+      },
+      requestOptions
     );
     this.state.updateUsers(data.users);
     return data;
@@ -15310,13 +15577,14 @@ var StreamChat = class _StreamChat {
    * searchUserGroups - Search user groups by prefix for autocomplete
    *
    * @param {SearchUserGroupsOptions} options The search options
-   *
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    * @return {Promise<SearchUserGroupsResponse>} User Group Search Response
    */
-  async searchUserGroups(options) {
+  async searchUserGroups(options, requestOptions = {}) {
     return await this.get(
       this.baseURL + "/usergroups/search",
-      options
+      options,
+      requestOptions
     );
   }
   /**
@@ -15436,10 +15704,11 @@ var StreamChat = class _StreamChat {
    * @param {ChannelSort} [sort] Sort options, for instance {created_at: -1}.
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_updated: -1}, {created_at: 1}]
    * @param {ChannelOptions} [options] Options object. Can include predefined_filter, filter_values, and sort_values for using predefined filters.
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<QueryChannelsAPIResponse>} full search channels response
    */
-  async queryChannelsRequestWithResponse(filterConditions, sort = [], options = {}) {
+  async queryChannelsRequestWithResponse(filterConditions, sort = [], options = {}, requestOptions = {}) {
     const defaultOptions = {
       state: true,
       watch: true,
@@ -15464,7 +15733,11 @@ var StreamChat = class _StreamChat {
       ...defaultOptions,
       ...restOptions
     };
-    return await this.post(this.baseURL + "/channels", payload);
+    return await this.post(
+      this.baseURL + "/channels",
+      payload,
+      requestOptions
+    );
   }
   /**
    * queryChannelsRequest - Queries channels and returns the raw channel response list.
@@ -15493,7 +15766,9 @@ var StreamChat = class _StreamChat {
     const queryChannelsResponse = await this.queryChannelsRequestWithResponse(
       filterConditions,
       sort,
-      options
+      options,
+      // stateOptions is never serialized, so it carries the abort signal
+      { signal: stateOptions.signal }
     );
     const channels = queryChannelsResponse.channels;
     this.dispatchEvent({
@@ -15610,10 +15885,11 @@ var StreamChat = class _StreamChat {
    * @param {ChannelFilters} filterConditions MongoDB style filter conditions
    * @param {MessageFilters | string} query search query or object MongoDB style filters
    * @param {SearchOptions} [options] Option object, {user_id: 'tommaso'}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<SearchAPIResponse>} search messages response
    */
-  async search(filterConditions, query, options = {}) {
+  async search(filterConditions, query, options = {}, requestOptions = {}) {
     if (options.offset && options.next) {
       throw Error(`Cannot specify offset with next`);
     }
@@ -15630,7 +15906,11 @@ var StreamChat = class _StreamChat {
       throw Error(`Invalid type ${typeof query} for query parameter`);
     }
     await this.wsPromise;
-    return await this.get(this.baseURL + "/search", { payload });
+    return await this.get(
+      this.baseURL + "/search",
+      { payload },
+      requestOptions
+    );
   }
   /**
    * setLocalDevice - Set the device info for the current client(device) that will be sent via WS connection automatically
@@ -16071,6 +16351,11 @@ var StreamChat = class _StreamChat {
   }
   /**
    * unflagMessage - unflag a message
+   *
+   * @deprecated The `/moderation/unflag` endpoint is deprecated and is a no-op on
+   * the backend - calling this resolves successfully but does not remove the flag.
+   * Use `client.moderation.submitAction()` against the review queue item instead.
+   *
    * @param {string} targetMessageID
    * @param {string} [options.user_id] currentUserID, only used with serverside auth
    * @returns {Promise<APIResponse>}
@@ -16083,6 +16368,11 @@ var StreamChat = class _StreamChat {
   }
   /**
    * unflagUser - unflag a user
+   *
+   * @deprecated The `/moderation/unflag` endpoint is deprecated and is a no-op on
+   * the backend - calling this resolves successfully but does not remove the flag.
+   * Use `client.moderation.submitAction()` against the review queue item instead.
+   *
    * @param {string} targetID
    * @param {string} [options.user_id] currentUserID, only used with serverside auth
    * @returns {Promise<APIResponse>}
@@ -16367,7 +16657,10 @@ var StreamChat = class _StreamChat {
     if (!message.id) {
       throw Error("Please specify the message.id when calling updateMessage");
     }
-    const payload = toUpdatedMessagePayload(message);
+    const payload = sanitizeOutgoingAttachments({
+      client: this,
+      message: toUpdatedMessagePayload(message)
+    });
     if (typeof partialUserOrUserId === "string") {
       payload.user_id = partialUserOrUserId;
     } else if (typeof partialUserOrUserId?.id === "string") {
@@ -16667,6 +16960,7 @@ var StreamChat = class _StreamChat {
       headers: axiosRequestConfigHeaders,
       ...axiosRequestConfigRest
     } = this.options.axiosRequestConfig || {};
+    const resolvedSignal = options.config?.signal ?? axiosRequestConfigRest.signal ?? signal;
     return {
       params: {
         user_id: this.userID,
@@ -16682,9 +16976,9 @@ var StreamChat = class _StreamChat {
         ...options.headers,
         ...axiosRequestConfigHeaders || {}
       },
-      ...signal ? { signal } : {},
       ...options.config,
-      ...axiosRequestConfigRest || {}
+      ...axiosRequestConfigRest,
+      ...resolvedSignal ? { signal: resolvedSignal } : {}
     };
   }
   _getToken() {
@@ -16824,8 +17118,12 @@ var StreamChat = class _StreamChat {
    *
    * @returns {Promise<APIResponse>}
    */
-  searchRoles(options) {
-    return this.get(`${this.baseURL}/roles/search`, options);
+  searchRoles(options, requestOptions = {}) {
+    return this.get(
+      `${this.baseURL}/roles/search`,
+      options,
+      requestOptions
+    );
   }
   /** deleteRole - deletes a custom role
    *
@@ -18182,7 +18480,8 @@ import { isAxiosError } from "axios";
 var OfflineDBSyncManager = class {
   constructor({
     client,
-    offlineDb
+    offlineDb,
+    syncMaxEventCount
   }) {
     this.syncStatus = false;
     this.connectionChangedListener = null;
@@ -18299,13 +18598,23 @@ var OfflineDBSyncManager = class {
             await this.offlineDb.resetDB();
           } else {
             const result = await this.client.sync(cids, lastSyncedAtDate.toISOString());
-            const queryPromises = result.events.map(
-              (event) => this.offlineDb.handleEvent({ event, execute: false })
-            );
-            const queriesArray = await Promise.all(queryPromises);
-            const queries = queriesArray.flat();
-            if (queries.length) {
-              await this.offlineDb.executeSqlBatch(queries);
+            const { syncMaxEventCount } = this;
+            const exceedsLimit = typeof syncMaxEventCount === "number" && syncMaxEventCount > 0 && result.events.length > syncMaxEventCount;
+            if (exceedsLimit) {
+              this.client.logger(
+                "warn",
+                `Skipping sync event replay: received ${result.events.length} events, which exceeds the configured limit of ${syncMaxEventCount}. Visible channels are refreshed on reconnect instead.`,
+                { tags: ["sync", "offline"] }
+              );
+            } else {
+              const queryPromises = result.events.map(
+                (event) => this.offlineDb.handleEvent({ event, execute: false })
+              );
+              const queriesArray = await Promise.all(queryPromises);
+              const queries = queriesArray.flat();
+              if (queries.length) {
+                await this.offlineDb.executeSqlBatch(queries);
+              }
             }
           }
         }
@@ -18349,12 +18658,16 @@ var OfflineDBSyncManager = class {
     };
     this.client = client;
     this.offlineDb = offlineDb;
+    this.syncMaxEventCount = syncMaxEventCount;
   }
 };
 
 // src/offline-support/offline_support_api.ts
 var AbstractOfflineDB = class {
-  constructor({ client }) {
+  constructor({
+    client,
+    syncMaxEventCount
+  }) {
     /**
      * Initializes the DB as well as its syncManager for a given userId.
      * It will update the DBs reactive state with initialization values.
@@ -18820,6 +19133,7 @@ var AbstractOfflineDB = class {
         return this.handleMessageUpdatedEvent({ event, execute });
       }
       if (type === "message.read" || type === "notification.mark_read") {
+        if (event.thread) return [];
         return this.handleRead({ event, unreadMessages: 0, execute });
       }
       if (type === "message.read_locally") {
@@ -19044,7 +19358,11 @@ var AbstractOfflineDB = class {
       }
     };
     this.client = client;
-    this.syncManager = new OfflineDBSyncManager({ client, offlineDb: this });
+    this.syncManager = new OfflineDBSyncManager({
+      client,
+      offlineDb: this,
+      syncMaxEventCount
+    });
     this.state = new StateStore({
       initialized: false,
       userId: this.client.userID
@@ -19382,6 +19700,7 @@ export {
   createMessageComposerStateCompositionMiddleware,
   createPollComposerStateMiddleware,
   createPostUploadAttachmentEnrichmentMiddleware,
+  createSendWithPendingUploadsAttachmentsMiddleware,
   createSharedLocationCompositionMiddleware,
   createTextComposerCompositionMiddleware,
   createTextComposerPreValidationMiddleware,
@@ -19410,6 +19729,7 @@ export {
   getTokenizedSuggestionDisplayName,
   getTriggerCharWithToken,
   gunzipPayload,
+  hasPending,
   insertItemWithTrigger,
   isAudioAttachment,
   isBlobButNotFile,
@@ -19417,6 +19737,7 @@ export {
   isFileAttachment,
   isFileList,
   isFileReference,
+  isFinishedUpload,
   isGiphyAttachment,
   isImageAttachment,
   isImageFile,
@@ -19429,9 +19750,11 @@ export {
   isLocalVoiceRecordingAttachment,
   isOwnUser,
   isPatch,
+  isPendingUpload,
   isScrapedContent,
   isSharedLocationResponse,
   isTargetedOptionTextUpdate,
+  isUploadCancellation,
   isUploadedAttachment,
   isVideoAttachment,
   isVoiceRecordingAttachment,
@@ -19451,11 +19774,14 @@ export {
   readFileAsArrayBuffer,
   removeDiacritics,
   replaceWordWithEntity,
+  settled,
   stripCommandFromText,
   stripMentionTokens,
   textIsEmpty,
   timeLeftMs,
   verifyAndParseWebhook,
-  verifySignature
+  verifySignature,
+  withCancellation,
+  withoutConcurrency
 };
 //# sourceMappingURL=index.mjs.map