stream-chat 9.42.3 → 9.43.1

package/dist/esm/index.mjs

@@ -3086,9 +3086,51 @@ var _AttachmentManager = class _AttachmentManager {
     this.setCustomUploadFn = (doUploadRequest) => {
       this.composer.updateConfig({ attachments: { doUploadRequest } });
     };
+    this.cancelAttachmentUploads = (attachments = this.attachments) => {
+      for (const { localMetadata } of attachments) {
+        this.client.uploadManager.deleteUploadRecord(localMetadata.id);
+      }
+    };
+    this.normalizeSnapshotAttachment = (attachment) => {
+      if (attachment.localMetadata.uploadState !== "uploading") return attachment;
+      this.client.uploadManager.deleteUploadRecord(attachment.localMetadata.id);
+      return {
+        ...attachment,
+        localMetadata: {
+          ...attachment.localMetadata,
+          uploadProgress: void 0,
+          uploadState: "failed"
+        }
+      };
+    };
     this.initState = ({ message } = {}) => {
       this.state.next(initState({ message }));
     };
+    this.getSnapshot = () => {
+      const state = this.state.getLatestValue();
+      let hasUpdates = false;
+      const attachments = state.attachments.map(this.normalizeSnapshotAttachment);
+      for (let i = 0; i < attachments.length; i++) {
+        if (attachments[i] !== state.attachments[i]) {
+          hasUpdates = true;
+          break;
+        }
+      }
+      return hasUpdates ? { ...state, attachments } : state;
+    };
+    this.restoreSnapshot = (snapshot) => {
+      this.cancelAttachmentUploads(this.attachments);
+      this.state.next(snapshot);
+    };
+    this.setAttachments = (attachments) => {
+      this.state.partialNext({ attachments });
+    };
+    this.clearAttachments = () => {
+      if (!this.attachments.length) return;
+      this.removeAttachments(
+        this.attachments.map((attachment) => attachment.localMetadata.id)
+      );
+    };
     this.getAttachmentIndex = (localId) => {
       const attachmentsById = this.attachmentsById;
       return this.attachments.indexOf(attachmentsById[localId]);
@@ -3609,6 +3651,10 @@ var CustomDataManager = class {
     this.initState = ({ message } = {}) => {
       this.state.next(initState2({ composer: this.composer, message }));
     };
+    this.getSnapshot = () => this.state.getLatestValue();
+    this.restoreSnapshot = (snapshot) => {
+      this.state.next(snapshot);
+    };
     this.composer = composer;
     this.state = new StateStore(initState2({ composer, message }));
   }
@@ -3664,8 +3710,13 @@ var _LinkPreviewsManager = class _LinkPreviewsManager {
   constructor({ composer, message }) {
     this.shouldDiscardEnrichQueries = false;
     this.initState = ({ message } = {}) => {
+      this.cancelURLEnrichment();
       this.state.next(initState3({ message: this.enabled ? message : void 0 }));
     };
+    this.getSnapshot = () => this.state.getLatestValue();
+    this.restoreSnapshot = (snapshot) => {
+      this.state.next(snapshot);
+    };
     this._findAndEnrichUrls = async (text) => {
       if (!this.enabled) return;
       const urls = this.config.findURLFn(text);
@@ -3718,8 +3769,8 @@ var _LinkPreviewsManager = class _LinkPreviewsManager {
       );
     };
     this.cancelURLEnrichment = () => {
-      this.findAndEnrichUrls.cancel();
-      this.findAndEnrichUrls.flush();
+      this.findAndEnrichUrls.cancel?.();
+      this.findAndEnrichUrls.flush?.();
     };
     /**
      * Clears all non-dismissed previews when the text composer is cleared.
@@ -3861,6 +3912,10 @@ var LocationComposer = class {
     this.initState = ({ message } = {}) => {
       this.state.next(initState4({ message }));
     };
+    this.getSnapshot = () => this.state.getLatestValue();
+    this.restoreSnapshot = (snapshot) => {
+      this.state.next(snapshot);
+    };
     this.setData = (data) => {
       if (!this.config.enabled) return;
       if (!data.latitude || !data.longitude) return;
@@ -3897,6 +3952,65 @@ var LocationComposer = class {
   }
 };
 
+// src/messageComposer/MessageComposerEffectHandlers.ts
+var applyCommandActivationEffect = (effect, composer) => {
+  const snapshot = composer.getSnapshot();
+  if (effect.stateToRestore) {
+    snapshot.textComposer = {
+      ...snapshot.textComposer,
+      ...effect.stateToRestore,
+      command: null
+    };
+  }
+  composer.captureSnapshot(snapshot);
+  composer.textComposer.state.next({
+    command: effect.command,
+    mentionedUsers: [],
+    suggestions: void 0,
+    selection: { start: 0, end: 0 },
+    text: ""
+  });
+  const attachmentsToCancel = composer.attachmentManager.attachments;
+  composer.attachmentManager.initState();
+  composer.attachmentManager.cancelAttachmentUploads(attachmentsToCancel);
+  composer.linkPreviewsManager.initState();
+  composer.locationComposer.initState();
+  composer.pollComposer.initState();
+  composer.customDataManager.initState();
+};
+var applyCommandClearEffect = (_, composer) => {
+  const snapshot = composer.popSnapshot();
+  if (!snapshot) return;
+  composer.restoreSnapshot(snapshot);
+};
+var MessageComposerEffectHandlers = class {
+  constructor(options) {
+    this.options = options;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.registerDefaultHandlers = () => {
+      this.registerEffectHandler(
+        "command.activate",
+        applyCommandActivationEffect
+      );
+      this.registerEffectHandler(
+        "command.clear",
+        applyCommandClearEffect
+      );
+    };
+    this.registerEffectHandler = (type, handler) => {
+      this.handlers.set(type, handler);
+    };
+    this.applyEffects = (effects = []) => {
+      effects.forEach((effect) => this.applyEffect(effect));
+    };
+    this.applyEffect = (effect) => {
+      const handler = this.handlers.get(effect.type);
+      handler?.(effect, this.options.composer);
+    };
+    this.registerDefaultHandlers();
+  }
+};
+
 // src/messageComposer/middleware/pollComposer/state.ts
 var VALID_MAX_VOTES_VALUE_REGEX = /^([2-9]|10)$/;
 var MAX_POLL_OPTIONS = 100;
@@ -4187,6 +4301,10 @@ var PollComposer = class {
     this.initState = () => {
       this.state.next(this.initialState);
     };
+    this.getSnapshot = () => this.state.getLatestValue();
+    this.restoreSnapshot = (snapshot) => {
+      this.state.next(snapshot);
+    };
     /**
      * Updates specified fields and generates relevant errors
      * @param data
@@ -4449,667 +4567,239 @@ var createDraftCustomDataCompositionMiddleware = (composer) => ({
   }
 });
 
-// src/messageComposer/middleware/messageComposer/compositionValidation.ts
-var createCompositionValidationMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/data-validation",
-  handlers: {
-    compose: async ({
-      state,
-      discard,
-      forward
-    }) => {
-      const { maxLengthOnSend } = composer.config.text ?? {};
-      const inputText = state.message.text ?? "";
-      const hasExceededMaxLength = typeof maxLengthOnSend === "number" && inputText.length > maxLengthOnSend;
-      if (composer.compositionIsEmpty || hasExceededMaxLength) {
-        return await discard();
-      }
-      return await forward();
-    }
+// src/errors.ts
+var APIErrorCodes = {
+  "-1": { name: "InternalSystemError", retryable: true },
+  "2": { name: "AccessKeyError", retryable: false },
+  "3": { name: "AuthenticationFailedError", retryable: true },
+  "4": { name: "InputError", retryable: false },
+  "6": { name: "DuplicateUsernameError", retryable: false },
+  "9": { name: "RateLimitError", retryable: true },
+  "16": { name: "DoesNotExistError", retryable: false },
+  "17": { name: "NotAllowedError", retryable: false },
+  "18": { name: "EventNotSupportedError", retryable: false },
+  "19": { name: "ChannelFeatureNotSupportedError", retryable: false },
+  "20": { name: "MessageTooLongError", retryable: false },
+  "21": { name: "MultipleNestingLevelError", retryable: false },
+  "22": { name: "PayloadTooBigError", retryable: false },
+  "23": { name: "RequestTimeoutError", retryable: true },
+  "24": { name: "MaxHeaderSizeExceededError", retryable: false },
+  "40": { name: "AuthErrorTokenExpired", retryable: false },
+  "41": { name: "AuthErrorTokenNotValidYet", retryable: false },
+  "42": { name: "AuthErrorTokenUsedBeforeIssuedAt", retryable: false },
+  "43": { name: "AuthErrorTokenSignatureInvalid", retryable: false },
+  "44": { name: "CustomCommandEndpointMissingError", retryable: false },
+  "45": { name: "CustomCommandEndpointCallError", retryable: true },
+  "46": { name: "ConnectionIDNotFoundError", retryable: false },
+  "60": { name: "CoolDownError", retryable: true },
+  "69": { name: "ErrWrongRegion", retryable: false },
+  "70": { name: "ErrQueryChannelPermissions", retryable: false },
+  "71": { name: "ErrTooManyConnections", retryable: true },
+  "99": { name: "AppSuspendedError", retryable: false }
+};
+function isAPIError(error) {
+  return error.code !== void 0;
+}
+function isErrorRetryable(error) {
+  if (!error.code) return false;
+  const err = APIErrorCodes[`${error.code}`];
+  if (!err) return false;
+  return err.retryable;
+}
+function isConnectionIDError(error) {
+  return error.code === 46;
+}
+function isWSFailure(err) {
+  if (typeof err.isWSFailure === "boolean") {
+    return err.isWSFailure;
   }
-});
-var createDraftCompositionValidationMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/draft-data-validation",
-  handlers: {
-    compose: async ({
-      state,
-      discard,
-      forward
-    }) => {
-      const hasData = !textIsEmpty(state.draft.text ?? "") || state.draft.attachments?.length || state.draft.poll_id || state.draft.quoted_message_id;
-      const shouldCreateDraft = composer.lastChangeOriginIsLocal && hasData;
-      if (!shouldCreateDraft) {
-        return await discard();
-      }
-      return await forward();
-    }
+  try {
+    return JSON.parse(err.message).isWSFailure;
+  } catch (_) {
+    return false;
   }
-});
+}
+function isErrorResponse(res) {
+  return !res.status || res.status < 200 || 300 <= res.status;
+}
 
-// src/messageComposer/middleware/messageComposer/linkPreviews.ts
-var createLinkPreviewsCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/link-previews",
-  handlers: {
-    compose: ({
-      state,
-      next,
-      forward
-    }) => {
-      const { linkPreviewsManager } = composer;
-      if (!linkPreviewsManager) return forward();
-      linkPreviewsManager.cancelURLEnrichment();
-      const someLinkPreviewsLoading = linkPreviewsManager.loadingPreviews.length > 0;
-      const someLinkPreviewsDismissed = linkPreviewsManager.dismissedPreviews.length > 0;
-      const linkPreviews = linkPreviewsManager.loadingPreviews.length > 0 ? [] : linkPreviewsManager.loadedPreviews.map(
-        (preview) => LinkPreviewsManager.getPreviewData(preview)
-      );
-      const attachments = (state.message.attachments ?? []).concat(
-        linkPreviews
-      );
-      if (!attachments.length) return forward();
-      const sendOptions = { ...state.sendOptions };
-      const skip_enrich_url = !someLinkPreviewsLoading && linkPreviews.length > 0 || someLinkPreviewsDismissed;
-      if (skip_enrich_url) {
-        sendOptions.skip_enrich_url = true;
-      }
-      return next({
-        ...state,
-        message: {
-          ...state.message,
-          attachments
-        },
-        localMessage: {
-          ...state.localMessage,
-          attachments
-        },
-        sendOptions
-      });
-    }
+// src/search/BaseSearchSource.ts
+var DEFAULT_SEARCH_SOURCE_OPTIONS = {
+  debounceMs: 300,
+  pageSize: 10
+};
+var BaseSearchSourceBase = class {
+  constructor(options) {
+    this.activate = () => {
+      if (this.isActive) return;
+      this.state.partialNext({ isActive: true });
+    };
+    this.deactivate = () => {
+      if (!this.isActive) return;
+      this.state.partialNext({ isActive: false });
+    };
+    this.canExecuteQuery = (newSearchString) => {
+      const hasNewSearchQuery = typeof newSearchString !== "undefined";
+      const searchString = newSearchString ?? this.searchQuery;
+      return !!(this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery) && searchString);
+    };
+    const { pageSize } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
+    this.pageSize = pageSize;
+    this.state = new StateStore(this.initialState);
   }
-});
-var createDraftLinkPreviewsCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/draft-link-previews",
-  handlers: {
-    compose: ({
-      state,
-      next,
-      forward
-    }) => {
-      const { linkPreviewsManager } = composer;
-      if (!linkPreviewsManager) return forward();
-      linkPreviewsManager.cancelURLEnrichment();
-      const linkPreviews = linkPreviewsManager.loadedPreviews.map(
-        (preview) => LinkPreviewsManager.getPreviewData(preview)
-      );
-      if (!linkPreviews.length) return forward();
-      return next({
-        ...state,
-        draft: {
-          ...state.draft,
-          attachments: (state.draft.attachments ?? []).concat(linkPreviews)
-        }
-      });
-    }
+  get lastQueryError() {
+    return this.state.getLatestValue().lastQueryError;
   }
-});
-
-// src/messageComposer/middleware/messageComposer/textComposer.ts
-var createTextComposerCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/text-composition",
-  handlers: {
-    compose: ({
-      state,
-      next,
-      forward
-    }) => {
-      if (!composer.textComposer) return forward();
-      const { mentionedUsers, text } = composer.textComposer;
-      const mentioned_users = Array.from(
-        new Set(
-          mentionedUsers.filter(
-            ({ id, name }) => text.includes(`@${id}`) || text.includes(`@${name}`)
-          )
-        )
-      );
-      if (!text && mentioned_users.length === 0) return forward();
-      return next({
-        ...state,
-        localMessage: {
-          ...state.localMessage,
-          mentioned_users,
-          text
-        },
-        message: {
-          ...state.message,
-          mentioned_users: mentioned_users.map((u) => u.id),
-          text
-        }
-      });
-    }
+  get hasNext() {
+    return this.state.getLatestValue().hasNext;
   }
-});
-var createDraftTextComposerCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/draft-text-composition",
-  handlers: {
-    compose: ({
-      state,
-      next,
-      forward
-    }) => {
-      if (!composer.textComposer) return forward();
-      const { maxLengthOnSend } = composer.config.text ?? {};
-      const { mentionedUsers, text: inputText } = composer.textComposer;
-      const mentioned_users = mentionedUsers.length ? Array.from(
-        new Set(
-          mentionedUsers.filter(
-            ({ id, name }) => inputText.includes(`@${id}`) || inputText.includes(`@${name}`)
-          )
-        )
-      ) : void 0;
-      const text = typeof maxLengthOnSend === "number" && inputText.length > maxLengthOnSend ? inputText.slice(0, maxLengthOnSend) : inputText;
-      return next({
-        ...state,
-        draft: {
-          ...state.draft,
-          mentioned_users: mentioned_users?.map((u) => u.id),
-          text
-        }
-      });
+  get hasResults() {
+    return Array.isArray(this.state.getLatestValue().items);
+  }
+  get isActive() {
+    return this.state.getLatestValue().isActive;
+  }
+  get isLoading() {
+    return this.state.getLatestValue().isLoading;
+  }
+  get initialState() {
+    return {
+      hasNext: true,
+      isActive: false,
+      isLoading: false,
+      items: void 0,
+      lastQueryError: void 0,
+      next: void 0,
+      offset: 0,
+      searchQuery: ""
+    };
+  }
+  get items() {
+    return this.state.getLatestValue().items;
+  }
+  get next() {
+    return this.state.getLatestValue().next;
+  }
+  get offset() {
+    return this.state.getLatestValue().offset;
+  }
+  get searchQuery() {
+    return this.state.getLatestValue().searchQuery;
+  }
+  getStateBeforeFirstQuery(newSearchString) {
+    return {
+      ...this.initialState,
+      isActive: this.isActive,
+      isLoading: true,
+      searchQuery: newSearchString
+    };
+  }
+  getStateAfterQuery(stateUpdate, isFirstPage) {
+    const current = this.state.getLatestValue();
+    return {
+      ...current,
+      lastQueryError: void 0,
+      // reset lastQueryError that can be overridden by the stateUpdate
+      ...stateUpdate,
+      isLoading: false,
+      items: isFirstPage ? stateUpdate.items : [...this.items ?? [], ...stateUpdate.items || []]
+    };
+  }
+  prepareStateForQuery(newSearchString) {
+    const hasNewSearchQuery = typeof newSearchString !== "undefined";
+    const searchString = newSearchString ?? this.searchQuery;
+    if (hasNewSearchQuery) {
+      this.state.next(this.getStateBeforeFirstQuery(newSearchString ?? ""));
+    } else {
+      this.state.partialNext({ isLoading: true });
     }
+    return { searchString, hasNewSearchQuery };
   }
-});
-
-// src/messageComposer/middleware/messageComposer/messageComposerState.ts
-var createMessageComposerStateCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/own-state",
-  handlers: {
-    compose: ({
-      state,
-      next
-    }) => {
-      const payload = {};
-      if (composer.quotedMessage) {
-        payload.quoted_message_id = composer.quotedMessage.id;
-      }
-      if (composer.pollId) {
-        payload.poll_id = composer.pollId;
-      }
-      if (composer.showReplyInChannel) {
-        payload.show_in_channel = true;
-      }
-      return next({
-        ...state,
-        localMessage: {
-          ...state.localMessage,
-          ...payload,
-          quoted_message: composer.quotedMessage ?? void 0
-        },
-        message: {
-          ...state.message,
-          ...payload
-        }
-      });
+  updatePaginationStateFromQuery(result) {
+    const { items, next } = result;
+    const stateUpdate = {};
+    if (Object.prototype.hasOwnProperty.call(result, "next")) {
+      stateUpdate.next = next;
+      stateUpdate.hasNext = !!next;
+    } else {
+      stateUpdate.offset = (this.offset ?? 0) + items.length;
+      stateUpdate.hasNext = items.length === this.pageSize;
     }
+    return stateUpdate;
   }
-});
-var createDraftMessageComposerStateCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/draft-own-state",
-  handlers: {
-    compose: ({
-      state,
-      next
-    }) => {
-      const payload = {};
-      if (composer.quotedMessage) {
-        payload.quoted_message_id = composer.quotedMessage.id;
-      }
-      if (composer.pollId) {
-        payload.poll_id = composer.pollId;
-      }
-      if (composer.showReplyInChannel) {
-        payload.show_in_channel = true;
+  resetState() {
+    this.state.next(this.initialState);
+  }
+  resetStateAndActivate() {
+    this.resetState();
+    this.activate();
+  }
+};
+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 });
+  }
+  async executeQuery(newSearchString) {
+    if (!this.canExecuteQuery(newSearchString)) return;
+    const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
+    let stateUpdate = {};
+    try {
+      const results = await this.query(searchString);
+      if (!results) return;
+      const { items } = results;
+      stateUpdate = this.updatePaginationStateFromQuery(results);
+      stateUpdate.items = await this.filterQueryResults(items);
+    } catch (e) {
+      stateUpdate.lastQueryError = e;
+      if (isAPIError(e) && !isErrorRetryable(e)) {
+        stateUpdate.hasNext = false;
       }
-      return next({
-        ...state,
-        draft: {
-          ...state.draft,
-          ...payload
-        }
-      });
+    } finally {
+      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
     }
   }
-});
-
-// src/messageComposer/middleware/messageComposer/userDataInjection.ts
-var createUserDataInjectionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/user-data-injection",
-  handlers: {
-    compose: ({
-      state,
-      next,
-      forward
-    }) => {
-      if (!composer.client.user) {
-        return forward();
+  cancelScheduledQuery() {
+    this.searchDebounced.cancel();
+  }
+};
+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);
+    let stateUpdate = {};
+    try {
+      const results = this.query(searchString);
+      if (!results) return;
+      const { items } = results;
+      stateUpdate = this.updatePaginationStateFromQuery(results);
+      stateUpdate.items = this.filterQueryResults(items);
+    } catch (e) {
+      stateUpdate.lastQueryError = e;
+      if (isAPIError(e) && !isErrorRetryable(e)) {
+        stateUpdate.hasNext = false;
       }
-      const { channel_mutes, devices, mutes, ...messageUser } = composer.client.user;
-      return next({
-        ...state,
-        localMessage: {
-          ...state.localMessage,
-          user: messageUser,
-          user_id: messageUser.id
-        }
-      });
+    } finally {
+      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
     }
   }
-});
-
-// src/messageComposer/middleware/messageComposer/pollOnly.ts
-var pollLocalMessageNullifiedFields = {
-  attachments: [],
-  mentioned_users: [],
-  parent_id: void 0,
-  quoted_message: void 0,
-  text: ""
-};
-var createPollOnlyCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/poll-only",
-  handlers: {
-    compose: ({
-      state,
-      complete,
-      forward
-    }) => {
-      const pollId = composer.pollId;
-      const isEditingMessage = !!composer.editedMessage;
-      const isComposingThreadReply = !!composer.threadId;
-      if (!pollId || isComposingThreadReply || isEditingMessage) return forward();
-      return complete({
-        ...state,
-        localMessage: {
-          ...state.localMessage,
-          ...pollLocalMessageNullifiedFields,
-          poll_id: pollId
-        },
-        message: {
-          id: state.localMessage.id,
-          poll_id: pollId
-        }
-      });
-    }
-  }
-});
-
-// src/messageComposer/middleware/messageComposer/sharedLocation.ts
-var createSharedLocationCompositionMiddleware = (composer) => ({
-  id: "stream-io/message-composer-middleware/shared-location",
-  handlers: {
-    compose: ({
-      state,
-      next,
-      forward
-    }) => {
-      const { locationComposer } = composer;
-      const location = locationComposer.validLocation;
-      if (!locationComposer || !location || !composer.client.user) return forward();
-      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-      return next({
-        ...state,
-        localMessage: {
-          ...state.localMessage,
-          shared_location: {
-            ...location,
-            channel_cid: composer.channel.cid,
-            created_at: timestamp,
-            updated_at: timestamp,
-            user_id: composer.client.user.id
-          }
-        },
-        message: {
-          ...state.message,
-          shared_location: location
-        }
-      });
-    }
-  }
-});
-
-// src/messageComposer/middleware/messageComposer/MessageComposerMiddlewareExecutor.ts
-var MessageComposerMiddlewareExecutor = class extends MiddlewareExecutor {
-  constructor({ composer }) {
-    super();
-    this.use([
-      createUserDataInjectionMiddleware(composer),
-      createPollOnlyCompositionMiddleware(composer),
-      createTextComposerCompositionMiddleware(composer),
-      createAttachmentsCompositionMiddleware(composer),
-      createLinkPreviewsCompositionMiddleware(composer),
-      createSharedLocationCompositionMiddleware(composer),
-      createMessageComposerStateCompositionMiddleware(composer),
-      createCustomDataCompositionMiddleware(composer),
-      createCompositionValidationMiddleware(composer),
-      createCompositionDataCleanupMiddleware(composer)
-    ]);
-  }
-};
-var MessageDraftComposerMiddlewareExecutor = class extends MiddlewareExecutor {
-  constructor({ composer }) {
-    super();
-    this.use([
-      createDraftTextComposerCompositionMiddleware(composer),
-      createDraftAttachmentsCompositionMiddleware(composer),
-      createDraftLinkPreviewsCompositionMiddleware(composer),
-      createDraftMessageComposerStateCompositionMiddleware(composer),
-      createDraftCustomDataCompositionMiddleware(composer),
-      createDraftCompositionValidationMiddleware(composer)
-    ]);
-  }
-};
-
-// src/messageComposer/middleware/messageComposer/commandInjection.ts
-var createCommandInjectionMiddleware = (composer) => ({
-  handlers: {
-    compose: ({
-      forward,
-      next,
-      state
-    }) => {
-      const command = composer.textComposer.command;
-      if (!command) {
-        return forward();
-      }
-      const { text } = state.localMessage;
-      const injection = `/${command?.name}`;
-      const enrichedText = `${injection} ${text}`;
-      return next({
-        ...state,
-        localMessage: {
-          ...state.localMessage,
-          text: enrichedText
-        },
-        message: {
-          ...state.message,
-          text: enrichedText
-        }
-      });
-    }
-  },
-  id: "stream-io/message-composer-middleware/command-string-injection"
-});
-var createDraftCommandInjectionMiddleware = (composer) => ({
-  handlers: {
-    compose: ({
-      forward,
-      next,
-      state
-    }) => {
-      const command = composer.textComposer.command;
-      if (!command) {
-        return forward();
-      }
-      const { text } = state.draft;
-      const injection = `/${command?.name}`;
-      const enrichedText = `${injection} ${text}`;
-      return next({
-        ...state,
-        draft: {
-          ...state.draft,
-          text: enrichedText
-        }
-      });
-    }
-  },
-  id: "stream-io/message-composer-middleware/draft-command-string-injection"
-});
-
-// src/messageComposer/middleware/textComposer/activeCommandGuard.ts
-var createActiveCommandGuardMiddleware = () => ({
-  handlers: {
-    onChange: ({ complete, forward, state }) => {
-      if (state.command) {
-        return complete(state);
-      }
-      return forward();
-    },
-    onSuggestionItemSelect: ({ forward }) => forward()
-  },
-  id: "stream-io/text-composer/active-command-guard"
-});
-
-// src/errors.ts
-var APIErrorCodes = {
-  "-1": { name: "InternalSystemError", retryable: true },
-  "2": { name: "AccessKeyError", retryable: false },
-  "3": { name: "AuthenticationFailedError", retryable: true },
-  "4": { name: "InputError", retryable: false },
-  "6": { name: "DuplicateUsernameError", retryable: false },
-  "9": { name: "RateLimitError", retryable: true },
-  "16": { name: "DoesNotExistError", retryable: false },
-  "17": { name: "NotAllowedError", retryable: false },
-  "18": { name: "EventNotSupportedError", retryable: false },
-  "19": { name: "ChannelFeatureNotSupportedError", retryable: false },
-  "20": { name: "MessageTooLongError", retryable: false },
-  "21": { name: "MultipleNestingLevelError", retryable: false },
-  "22": { name: "PayloadTooBigError", retryable: false },
-  "23": { name: "RequestTimeoutError", retryable: true },
-  "24": { name: "MaxHeaderSizeExceededError", retryable: false },
-  "40": { name: "AuthErrorTokenExpired", retryable: false },
-  "41": { name: "AuthErrorTokenNotValidYet", retryable: false },
-  "42": { name: "AuthErrorTokenUsedBeforeIssuedAt", retryable: false },
-  "43": { name: "AuthErrorTokenSignatureInvalid", retryable: false },
-  "44": { name: "CustomCommandEndpointMissingError", retryable: false },
-  "45": { name: "CustomCommandEndpointCallError", retryable: true },
-  "46": { name: "ConnectionIDNotFoundError", retryable: false },
-  "60": { name: "CoolDownError", retryable: true },
-  "69": { name: "ErrWrongRegion", retryable: false },
-  "70": { name: "ErrQueryChannelPermissions", retryable: false },
-  "71": { name: "ErrTooManyConnections", retryable: true },
-  "99": { name: "AppSuspendedError", retryable: false }
-};
-function isAPIError(error) {
-  return error.code !== void 0;
-}
-function isErrorRetryable(error) {
-  if (!error.code) return false;
-  const err = APIErrorCodes[`${error.code}`];
-  if (!err) return false;
-  return err.retryable;
-}
-function isConnectionIDError(error) {
-  return error.code === 46;
-}
-function isWSFailure(err) {
-  if (typeof err.isWSFailure === "boolean") {
-    return err.isWSFailure;
-  }
-  try {
-    return JSON.parse(err.message).isWSFailure;
-  } catch (_) {
-    return false;
-  }
-}
-function isErrorResponse(res) {
-  return !res.status || res.status < 200 || 300 <= res.status;
-}
-
-// src/search/BaseSearchSource.ts
-var DEFAULT_SEARCH_SOURCE_OPTIONS = {
-  debounceMs: 300,
-  pageSize: 10
-};
-var BaseSearchSourceBase = class {
-  constructor(options) {
-    this.activate = () => {
-      if (this.isActive) return;
-      this.state.partialNext({ isActive: true });
-    };
-    this.deactivate = () => {
-      if (!this.isActive) return;
-      this.state.partialNext({ isActive: false });
-    };
-    this.canExecuteQuery = (newSearchString) => {
-      const hasNewSearchQuery = typeof newSearchString !== "undefined";
-      const searchString = newSearchString ?? this.searchQuery;
-      return !!(this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery) && searchString);
-    };
-    const { pageSize } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
-    this.pageSize = pageSize;
-    this.state = new StateStore(this.initialState);
-  }
-  get lastQueryError() {
-    return this.state.getLatestValue().lastQueryError;
-  }
-  get hasNext() {
-    return this.state.getLatestValue().hasNext;
-  }
-  get hasResults() {
-    return Array.isArray(this.state.getLatestValue().items);
-  }
-  get isActive() {
-    return this.state.getLatestValue().isActive;
-  }
-  get isLoading() {
-    return this.state.getLatestValue().isLoading;
-  }
-  get initialState() {
-    return {
-      hasNext: true,
-      isActive: false,
-      isLoading: false,
-      items: void 0,
-      lastQueryError: void 0,
-      next: void 0,
-      offset: 0,
-      searchQuery: ""
-    };
-  }
-  get items() {
-    return this.state.getLatestValue().items;
-  }
-  get next() {
-    return this.state.getLatestValue().next;
-  }
-  get offset() {
-    return this.state.getLatestValue().offset;
-  }
-  get searchQuery() {
-    return this.state.getLatestValue().searchQuery;
-  }
-  getStateBeforeFirstQuery(newSearchString) {
-    return {
-      ...this.initialState,
-      isActive: this.isActive,
-      isLoading: true,
-      searchQuery: newSearchString
-    };
-  }
-  getStateAfterQuery(stateUpdate, isFirstPage) {
-    const current = this.state.getLatestValue();
-    return {
-      ...current,
-      lastQueryError: void 0,
-      // reset lastQueryError that can be overridden by the stateUpdate
-      ...stateUpdate,
-      isLoading: false,
-      items: isFirstPage ? stateUpdate.items : [...this.items ?? [], ...stateUpdate.items || []]
-    };
-  }
-  prepareStateForQuery(newSearchString) {
-    const hasNewSearchQuery = typeof newSearchString !== "undefined";
-    const searchString = newSearchString ?? this.searchQuery;
-    if (hasNewSearchQuery) {
-      this.state.next(this.getStateBeforeFirstQuery(newSearchString ?? ""));
-    } else {
-      this.state.partialNext({ isLoading: true });
-    }
-    return { searchString, hasNewSearchQuery };
-  }
-  updatePaginationStateFromQuery(result) {
-    const { items, next } = result;
-    const stateUpdate = {};
-    if (Object.prototype.hasOwnProperty.call(result, "next")) {
-      stateUpdate.next = next;
-      stateUpdate.hasNext = !!next;
-    } else {
-      stateUpdate.offset = (this.offset ?? 0) + items.length;
-      stateUpdate.hasNext = items.length === this.pageSize;
-    }
-    return stateUpdate;
-  }
-  resetState() {
-    this.state.next(this.initialState);
-  }
-  resetStateAndActivate() {
-    this.resetState();
-    this.activate();
-  }
-};
-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 });
-  }
-  async executeQuery(newSearchString) {
-    if (!this.canExecuteQuery(newSearchString)) return;
-    const { hasNewSearchQuery, searchString } = this.prepareStateForQuery(newSearchString);
-    let stateUpdate = {};
-    try {
-      const results = await this.query(searchString);
-      if (!results) return;
-      const { items } = results;
-      stateUpdate = this.updatePaginationStateFromQuery(results);
-      stateUpdate.items = await this.filterQueryResults(items);
-    } catch (e) {
-      stateUpdate.lastQueryError = e;
-      if (isAPIError(e) && !isErrorRetryable(e)) {
-        stateUpdate.hasNext = false;
-      }
-    } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
-    }
-  }
-  cancelScheduledQuery() {
-    this.searchDebounced.cancel();
-  }
-};
-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);
-    let stateUpdate = {};
-    try {
-      const results = this.query(searchString);
-      if (!results) return;
-      const { items } = results;
-      stateUpdate = this.updatePaginationStateFromQuery(results);
-      stateUpdate.items = this.filterQueryResults(items);
-    } catch (e) {
-      stateUpdate.lastQueryError = e;
-      if (isAPIError(e) && !isErrorRetryable(e)) {
-        stateUpdate.hasNext = false;
-      }
-    } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
-    }
-  }
-  cancelScheduledQuery() {
-    this.searchDebounced.cancel();
-  }
+  cancelScheduledQuery() {
+    this.searchDebounced.cancel();
+  }
 };
 
 // src/search/SearchController.ts
@@ -5205,586 +4895,1095 @@ var SearchController = class {
   get activeSources() {
     return this.state.getLatestValue().sources.filter((s) => s.isActive);
   }
-  get isActive() {
-    return this.state.getLatestValue().isActive;
+  get isActive() {
+    return this.state.getLatestValue().isActive;
+  }
+  get searchQuery() {
+    return this.state.getLatestValue().searchQuery;
+  }
+  get searchSourceTypes() {
+    return this.sources.map((s) => s.type);
+  }
+};
+
+// src/pagination/BasePaginator.ts
+var DEFAULT_PAGINATION_OPTIONS = {
+  debounceMs: 300,
+  pageSize: 10
+};
+var BasePaginator = class {
+  constructor(options) {
+    this._isCursorPagination = false;
+    this.setDebounceOptions = ({ debounceMs }) => {
+      this._executeQueryDebounced = debounce(this.executeQuery.bind(this), debounceMs);
+    };
+    this.canExecuteQuery = (direction) => !this.isLoading && direction === "next" && this.hasNext || direction === "prev" && this.hasPrev;
+    this.next = () => this.executeQuery({ direction: "next" });
+    this.prev = () => this.executeQuery({ direction: "prev" });
+    this.nextDebounced = () => {
+      this._executeQueryDebounced({ direction: "next" });
+    };
+    this.prevDebounced = () => {
+      this._executeQueryDebounced({ direction: "prev" });
+    };
+    const { debounceMs, pageSize } = { ...DEFAULT_PAGINATION_OPTIONS, ...options };
+    this.pageSize = pageSize;
+    this.state = new StateStore(this.initialState);
+    this.setDebounceOptions({ debounceMs });
+  }
+  get lastQueryError() {
+    return this.state.getLatestValue().lastQueryError;
+  }
+  get hasNext() {
+    return this.state.getLatestValue().hasNext;
+  }
+  get hasPrev() {
+    return this.state.getLatestValue().hasPrev;
+  }
+  get hasResults() {
+    return Array.isArray(this.state.getLatestValue().items);
+  }
+  get isLoading() {
+    return this.state.getLatestValue().isLoading;
+  }
+  get initialState() {
+    return {
+      hasNext: true,
+      hasPrev: true,
+      //todo: check if optimistic value does not cause problems in UI
+      isLoading: false,
+      items: void 0,
+      lastQueryError: void 0,
+      cursor: void 0,
+      offset: 0
+    };
+  }
+  get items() {
+    return this.state.getLatestValue().items;
+  }
+  get cursor() {
+    return this.state.getLatestValue().cursor;
+  }
+  get offset() {
+    return this.state.getLatestValue().offset;
+  }
+  getStateBeforeFirstQuery() {
+    return {
+      ...this.initialState,
+      isLoading: true
+    };
+  }
+  getStateAfterQuery(stateUpdate, isFirstPage) {
+    const current = this.state.getLatestValue();
+    return {
+      ...current,
+      lastQueryError: void 0,
+      // reset lastQueryError that can be overridden by the stateUpdate
+      ...stateUpdate,
+      isLoading: false,
+      items: isFirstPage ? stateUpdate.items : [...this.items ?? [], ...stateUpdate.items || []]
+    };
+  }
+  async executeQuery({ direction }) {
+    if (!this.canExecuteQuery(direction)) return;
+    const isFirstPage = typeof this.items === "undefined";
+    if (isFirstPage) {
+      this.state.next(this.getStateBeforeFirstQuery());
+    } else {
+      this.state.partialNext({ isLoading: true });
+    }
+    const stateUpdate = {};
+    try {
+      const results = await this.query({ direction });
+      if (!results) return;
+      const { items, next, prev } = results;
+      if (isFirstPage && (next || prev)) {
+        this._isCursorPagination = true;
+      }
+      if (this._isCursorPagination) {
+        stateUpdate.cursor = { next: next || null, prev: prev || null };
+        stateUpdate.hasNext = !!next;
+        stateUpdate.hasPrev = !!prev;
+      } else {
+        stateUpdate.offset = (this.offset ?? 0) + items.length;
+        stateUpdate.hasNext = items.length === this.pageSize;
+      }
+      stateUpdate.items = await this.filterQueryResults(items);
+    } catch (e) {
+      stateUpdate.lastQueryError = e;
+    } finally {
+      this.state.next(this.getStateAfterQuery(stateUpdate, isFirstPage));
+    }
+  }
+  cancelScheduledQuery() {
+    this._executeQueryDebounced.cancel();
+  }
+  resetState() {
+    this.state.next(this.initialState);
+  }
+};
+
+// src/pagination/FilterBuilder.ts
+var FilterBuilder = class {
+  constructor(params) {
+    this.context = new StateStore(params?.initialContext ?? {});
+    this.filterConfig = new StateStore(
+      params?.initialFilterConfig ?? {}
+    );
+  }
+  updateFilterConfig(config) {
+    this.filterConfig.partialNext(config);
+  }
+  enableFilter(filterKey) {
+    const config = this.filterConfig.getLatestValue();
+    if (config[filterKey]) {
+      this.filterConfig.partialNext({
+        [filterKey]: {
+          ...config[filterKey],
+          enabled: true
+        }
+      });
+    }
+  }
+  disableFilter(filterKey) {
+    const config = this.filterConfig.getLatestValue();
+    if (config[filterKey]) {
+      this.filterConfig.partialNext({
+        [filterKey]: {
+          ...config[filterKey],
+          enabled: false
+        }
+      });
+    }
+  }
+  updateContext(newContext) {
+    this.context.partialNext(newContext);
+  }
+  buildFilters(params) {
+    const filters = {
+      ...params?.baseFilters ?? {}
+    };
+    const filterConfig = this.filterConfig.getLatestValue();
+    for (const key in filterConfig) {
+      const configItem = filterConfig[key];
+      if (!configItem?.enabled) continue;
+      const generated = configItem.generate({
+        ...this.context.getLatestValue(),
+        ...params?.context ?? {}
+      });
+      if (generated) Object.assign(filters, generated);
+    }
+    return filters;
+  }
+};
+
+// src/pagination/ReminderPaginator.ts
+var ReminderPaginator = class extends BasePaginator {
+  constructor(client, options) {
+    super(options);
+    this.query = async ({
+      direction
+    }) => {
+      const cursor = this.cursor?.[direction];
+      const {
+        reminders: items,
+        next,
+        prev
+      } = await this.client.queryReminders({
+        filter: this.filters,
+        sort: this.sort,
+        limit: this.pageSize,
+        [direction]: cursor
+      });
+      return { items, next, prev };
+    };
+    this.filterQueryResults = (items) => items;
+    this.client = client;
+  }
+  get filters() {
+    return this._filters;
+  }
+  get sort() {
+    return this._sort;
   }
-  get searchQuery() {
-    return this.state.getLatestValue().searchQuery;
+  set filters(filters) {
+    this._filters = filters;
+    this.resetState();
   }
-  get searchSourceTypes() {
-    return this.sources.map((s) => s.type);
+  set sort(sort) {
+    this._sort = sort;
+    this.resetState();
   }
 };
 
-// src/pagination/BasePaginator.ts
-var DEFAULT_PAGINATION_OPTIONS = {
-  debounceMs: 300,
-  pageSize: 10
-};
-var BasePaginator = class {
-  constructor(options) {
-    this._isCursorPagination = false;
-    this.setDebounceOptions = ({ debounceMs }) => {
-      this._executeQueryDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-    };
-    this.canExecuteQuery = (direction) => !this.isLoading && direction === "next" && this.hasNext || direction === "prev" && this.hasPrev;
-    this.next = () => this.executeQuery({ direction: "next" });
-    this.prev = () => this.executeQuery({ direction: "prev" });
-    this.nextDebounced = () => {
-      this._executeQueryDebounced({ direction: "next" });
-    };
-    this.prevDebounced = () => {
-      this._executeQueryDebounced({ direction: "prev" });
-    };
-    const { debounceMs, pageSize } = { ...DEFAULT_PAGINATION_OPTIONS, ...options };
-    this.pageSize = pageSize;
-    this.state = new StateStore(this.initialState);
-    this.setDebounceOptions({ debounceMs });
+// src/search/UserSearchSource.ts
+var UserSearchSource = class extends BaseSearchSource {
+  constructor(client, options, filterBuilderOptions = {}) {
+    super(options);
+    this.type = "users";
+    this.client = client;
+    this.filterBuilder = new FilterBuilder({
+      initialFilterConfig: {
+        $or: {
+          enabled: true,
+          generate: ({ searchQuery }) => searchQuery ? {
+            $or: [
+              { id: { $autocomplete: searchQuery } },
+              { name: { $autocomplete: searchQuery } }
+            ]
+          } : null
+        }
+      },
+      ...filterBuilderOptions
+    });
   }
-  get lastQueryError() {
-    return this.state.getLatestValue().lastQueryError;
+  async query(searchQuery) {
+    const filters = this.filterBuilder.buildFilters({
+      baseFilters: this.filters,
+      context: { searchQuery }
+    });
+    const sort = { id: 1, ...this.sort };
+    const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
+    const { users } = await this.client.queryUsers(filters, sort, options);
+    return { items: users };
   }
-  get hasNext() {
-    return this.state.getLatestValue().hasNext;
+  filterQueryResults(items) {
+    return items.filter((u) => u.id !== this.client.user?.id);
   }
-  get hasPrev() {
-    return this.state.getLatestValue().hasPrev;
+};
+
+// src/search/ChannelSearchSource.ts
+var ChannelSearchSource = class extends BaseSearchSource {
+  constructor(client, options, filterBuilderOptions = {}) {
+    super(options);
+    this.type = "channels";
+    this.client = client;
+    this.filterBuilder = new FilterBuilder({
+      ...filterBuilderOptions,
+      initialFilterConfig: {
+        name: {
+          enabled: true,
+          generate: ({ searchQuery }) => searchQuery ? { name: { $autocomplete: searchQuery } } : null
+        },
+        ...filterBuilderOptions.initialFilterConfig
+      }
+    });
   }
-  get hasResults() {
-    return Array.isArray(this.state.getLatestValue().items);
+  async query(searchQuery) {
+    const filters = this.filterBuilder.buildFilters({
+      baseFilters: {
+        ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
+        ...this.filters
+      },
+      context: { searchQuery }
+    });
+    const sort = this.sort ?? {};
+    const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
+    const items = await this.client.queryChannels(filters, sort, options);
+    return { items };
   }
-  get isLoading() {
-    return this.state.getLatestValue().isLoading;
+  filterQueryResults(items) {
+    return items;
   }
-  get initialState() {
-    return {
-      hasNext: true,
-      hasPrev: true,
-      //todo: check if optimistic value does not cause problems in UI
-      isLoading: false,
-      items: void 0,
-      lastQueryError: void 0,
-      cursor: void 0,
-      offset: 0
-    };
+};
+
+// src/search/MessageSearchSource.ts
+var MessageSearchSource = class extends BaseSearchSource {
+  constructor(client, options, filterBuilderOptions) {
+    super(options);
+    this.type = "messages";
+    this.client = client;
+    this.messageSearchChannelFilterBuilder = new FilterBuilder(filterBuilderOptions?.messageSearchChannel);
+    this.messageSearchFilterBuilder = new FilterBuilder({
+      ...filterBuilderOptions?.messageSearch,
+      initialFilterConfig: {
+        text: {
+          enabled: true,
+          generate: ({ searchQuery }) => searchQuery ? { text: searchQuery } : null
+        },
+        ...filterBuilderOptions?.messageSearch?.initialFilterConfig
+      }
+    });
+    this.channelQueryFilterBuilder = new FilterBuilder({
+      ...filterBuilderOptions?.channelQuery,
+      initialFilterConfig: {
+        cid: {
+          enabled: true,
+          generate: ({ cids }) => cids ? { cid: { $in: cids } } : null
+        },
+        ...filterBuilderOptions?.channelQuery?.initialFilterConfig
+      }
+    });
   }
-  get items() {
-    return this.state.getLatestValue().items;
+  async query(searchQuery) {
+    if (!this.client.userID || !searchQuery || this.next === null) return { items: [] };
+    const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
+      baseFilters: {
+        ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
+        ...this.messageSearchChannelFilters
+      },
+      context: { searchQuery }
+    });
+    const messageFilters = this.messageSearchFilterBuilder.buildFilters({
+      baseFilters: {
+        type: "regular",
+        ...this.messageSearchFilters
+      },
+      context: { searchQuery }
+    });
+    const sort = {
+      created_at: -1,
+      ...this.messageSearchSort
+    };
+    const options = {
+      limit: this.pageSize,
+      next: this.next,
+      sort
+    };
+    const { next, results } = await this.client.search(
+      channelFilters,
+      messageFilters,
+      options
+    );
+    const items = results.map(({ message }) => message);
+    const cids = Array.from(
+      items.reduce((acc, message) => {
+        if (message.cid && !this.client.activeChannels[message.cid]) acc.add(message.cid);
+        return acc;
+      }, /* @__PURE__ */ new Set())
+    );
+    if (cids.length > 0) {
+      const channelQueryFilters = this.channelQueryFilterBuilder.buildFilters({
+        baseFilters: this.channelQueryFilters,
+        context: { cids }
+      });
+      await this.client.queryChannels(
+        channelQueryFilters,
+        {
+          last_message_at: -1,
+          ...this.channelQuerySort
+        },
+        this.channelQueryOptions
+      );
+    }
+    return { items, next };
   }
-  get cursor() {
-    return this.state.getLatestValue().cursor;
+  filterQueryResults(items) {
+    return items;
   }
-  get offset() {
-    return this.state.getLatestValue().offset;
+};
+
+// src/messageComposer/middleware/textComposer/commandUtils.ts
+function escapeCommandRegExp(text) {
+  return text.replace(/[-[\]{}()*+?.,/\\^$|#]/g, "\\$&");
+}
+var getRawCommandName = (text) => text?.match(/^\/(\S+)(?:\s.*)?$/)?.[1];
+var getCompleteCommandInString = (text) => {
+  const match = text.match(/^\/(\S+)\s+.*/);
+  const commandName = match && match[1];
+  return commandName;
+};
+var stripCommandFromText = (text, commandName) => text.replace(new RegExp(`^${escapeCommandRegExp(`/${commandName}`)}\\s*`), "");
+var notifyCommandDisabled = (composer, command) => {
+  const disabledReason = composer.getCommandDisabledReason(command);
+  if (!disabledReason) return;
+  composer.client.notifications.addWarning({
+    message: disabledReason === "editing" ? "Command not available while editing" : "Command not available while replying",
+    origin: {
+      emitter: "MessageComposer",
+      context: { command, composer }
+    },
+    options: {
+      type: "validation:command:disabled",
+      metadata: {
+        command: command.name,
+        reason: disabledReason
+      }
+    }
+  });
+  return true;
+};
+
+// src/messageComposer/middleware/textComposer/textMiddlewareUtils.ts
+var getTriggerCharWithToken = ({
+  trigger,
+  text,
+  isCommand = false,
+  acceptTrailingSpaces = true
+}) => {
+  const escapedTrigger = escapeCommandRegExp(trigger);
+  const triggerNorWhitespace = `[^\\s${escapedTrigger}]*`;
+  const match = text.match(
+    new RegExp(
+      isCommand ? `^[${escapedTrigger}]${triggerNorWhitespace}$` : acceptTrailingSpaces ? `(?!^|\\W)?[${escapedTrigger}]${triggerNorWhitespace}\\s?${triggerNorWhitespace}$` : `(?!^|\\W)?[${escapedTrigger}]${triggerNorWhitespace}$`,
+      "g"
+    )
+  );
+  return match && match[match.length - 1].trim();
+};
+var insertItemWithTrigger = ({
+  insertText,
+  selection,
+  text,
+  trigger
+}) => {
+  const beforeCursor = text.slice(0, selection.end);
+  const afterCursor = text.slice(selection.end);
+  const lastIndex = beforeCursor.lastIndexOf(trigger);
+  const newText = beforeCursor.slice(0, lastIndex) + insertText + afterCursor;
+  return {
+    text: newText,
+    selection: {
+      start: lastIndex + insertText.length,
+      end: lastIndex + insertText.length
+    }
+  };
+};
+var replaceWordWithEntity = async ({
+  caretPosition,
+  getEntityString,
+  text
+}) => {
+  const lastWordRegex = /([^\s]+)(\s*)$/;
+  const match = lastWordRegex.exec(text.slice(0, caretPosition));
+  if (!match) return text;
+  const lastWord = match[1];
+  if (!lastWord) return text;
+  const spaces = match[2];
+  const newWord = await getEntityString(lastWord);
+  if (newWord == null) return text;
+  const textBeforeWord = text.slice(0, caretPosition - match[0].length);
+  const textAfterCaret = text.slice(caretPosition, -1);
+  return textBeforeWord + newWord + spaces + textAfterCaret;
+};
+var getTokenizedSuggestionDisplayName = ({
+  displayName,
+  searchToken
+}) => ({
+  tokenizedDisplayName: {
+    token: searchToken,
+    parts: searchToken ? displayName.split(new RegExp(`(${escapeCommandRegExp(searchToken)})`, "gi")).filter(Boolean) : [displayName]
   }
-  getStateBeforeFirstQuery() {
-    return {
-      ...this.initialState,
-      isLoading: true
+});
+
+// src/messageComposer/middleware/textComposer/commands.ts
+var CommandSearchSource = class extends BaseSearchSourceSync {
+  constructor(channel, options) {
+    super(options);
+    this.type = "commands";
+    this.canExecuteQuery = (newSearchString) => {
+      const hasNewSearchQuery = typeof newSearchString !== "undefined";
+      return this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery);
     };
+    this.channel = channel;
   }
-  getStateAfterQuery(stateUpdate, isFirstPage) {
-    const current = this.state.getLatestValue();
+  getStateBeforeFirstQuery(newSearchString) {
+    const newState = super.getStateBeforeFirstQuery(newSearchString);
+    const { items } = this.state.getLatestValue();
     return {
-      ...current,
-      lastQueryError: void 0,
-      // reset lastQueryError that can be overridden by the stateUpdate
-      ...stateUpdate,
-      isLoading: false,
-      items: isFirstPage ? stateUpdate.items : [...this.items ?? [], ...stateUpdate.items || []]
+      ...newState,
+      items
+      // preserve items to avoid flickering
     };
   }
-  async executeQuery({ direction }) {
-    if (!this.canExecuteQuery(direction)) return;
-    const isFirstPage = typeof this.items === "undefined";
-    if (isFirstPage) {
-      this.state.next(this.getStateBeforeFirstQuery());
-    } else {
-      this.state.partialNext({ isLoading: true });
-    }
-    const stateUpdate = {};
-    try {
-      const results = await this.query({ direction });
-      if (!results) return;
-      const { items, next, prev } = results;
-      if (isFirstPage && (next || prev)) {
-        this._isCursorPagination = true;
+  query(searchQuery) {
+    const channelConfig = this.channel.getConfig();
+    const commands = channelConfig?.commands || [];
+    const selectedCommands = commands.filter(
+      (command) => !!(command.name && command.name.toLowerCase().indexOf(searchQuery.toLowerCase()) !== -1)
+    );
+    selectedCommands.sort((a, b) => {
+      let nameA = a.name?.toLowerCase();
+      let nameB = b.name?.toLowerCase();
+      if (nameA?.indexOf(searchQuery) === 0) {
+        nameA = `0${nameA}`;
       }
-      if (this._isCursorPagination) {
-        stateUpdate.cursor = { next: next || null, prev: prev || null };
-        stateUpdate.hasNext = !!next;
-        stateUpdate.hasPrev = !!prev;
-      } else {
-        stateUpdate.offset = (this.offset ?? 0) + items.length;
-        stateUpdate.hasNext = items.length === this.pageSize;
+      if (nameB?.indexOf(searchQuery) === 0) {
+        nameB = `0${nameB}`;
       }
-      stateUpdate.items = await this.filterQueryResults(items);
-    } catch (e) {
-      stateUpdate.lastQueryError = e;
-    } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, isFirstPage));
-    }
+      if (nameA != null && nameB != null) {
+        if (nameA < nameB) {
+          return -1;
+        }
+        if (nameA > nameB) {
+          return 1;
+        }
+      }
+      return 0;
+    });
+    return {
+      items: selectedCommands.map((command) => ({
+        ...command,
+        id: command.name
+      })),
+      next: null
+    };
   }
-  cancelScheduledQuery() {
-    this._executeQueryDebounced.cancel();
+  filterQueryResults(items) {
+    return items;
   }
-  resetState() {
-    this.state.next(this.initialState);
+};
+var DEFAULT_OPTIONS = { minChars: 1, trigger: "/" };
+var createCommandsMiddleware = (channel, options) => {
+  const finalOptions = mergeWith(DEFAULT_OPTIONS, options ?? {});
+  let searchSource = new CommandSearchSource(channel);
+  if (options?.searchSource) {
+    searchSource = options.searchSource;
+    searchSource.resetState();
   }
+  searchSource.activate();
+  return {
+    id: "stream-io/text-composer/commands-middleware",
+    handlers: {
+      onChange: ({ state, next, complete, forward }) => {
+        if (!state.selection) return forward();
+        const finalText = state.text.slice(0, state.selection.end);
+        const commandName = getCompleteCommandInString(finalText);
+        if (commandName) {
+          const command = searchSource?.query(commandName).items[0];
+          const composer = options?.composer;
+          if (command && !composer?.isCommandDisabled(command)) {
+            return next({
+              ...state,
+              command,
+              suggestions: void 0
+            });
+          }
+        }
+        const triggerWithToken = getTriggerCharWithToken({
+          trigger: finalOptions.trigger,
+          text: finalText,
+          acceptTrailingSpaces: false,
+          isCommand: true
+        });
+        const newSearchTriggerred = triggerWithToken && triggerWithToken.length === finalOptions.minChars;
+        if (newSearchTriggerred) {
+          searchSource.resetStateAndActivate();
+        }
+        const triggerWasRemoved = !triggerWithToken || triggerWithToken.length < finalOptions.minChars;
+        if (triggerWasRemoved) {
+          const hasStaleSuggestions = state.suggestions?.trigger === finalOptions.trigger;
+          const newState = { ...state };
+          if (hasStaleSuggestions) {
+            delete newState.suggestions;
+          }
+          return next(newState);
+        }
+        return complete({
+          ...state,
+          command: null,
+          suggestions: {
+            query: triggerWithToken.slice(1),
+            searchSource,
+            trigger: finalOptions.trigger
+          }
+        });
+      },
+      onSuggestionItemSelect: ({ state, next, forward }) => {
+        const { selectedSuggestion } = state.change ?? {};
+        if (!selectedSuggestion || state.suggestions?.trigger !== finalOptions.trigger)
+          return forward();
+        const composer = options?.composer;
+        if (composer && notifyCommandDisabled(composer, selectedSuggestion)) {
+          return forward();
+        }
+        searchSource.resetStateAndActivate();
+        return next({
+          ...state,
+          ...insertItemWithTrigger({
+            insertText: `/${selectedSuggestion.name} `,
+            selection: state.selection,
+            text: state.text,
+            trigger: finalOptions.trigger
+          }),
+          command: selectedSuggestion,
+          suggestions: void 0
+        });
+      }
+    }
+  };
 };
 
-// src/pagination/FilterBuilder.ts
-var FilterBuilder = class {
-  constructor(params) {
-    this.context = new StateStore(params?.initialContext ?? {});
-    this.filterConfig = new StateStore(
-      params?.initialFilterConfig ?? {}
-    );
-  }
-  updateFilterConfig(config) {
-    this.filterConfig.partialNext(config);
+// src/messageComposer/middleware/messageComposer/compositionValidation.ts
+var getCommandByName = (searchSource, commandName) => {
+  if (!commandName) return;
+  const normalizedCommandName = commandName.toLowerCase();
+  return searchSource.query(normalizedCommandName).items.find((command) => command.name?.toLowerCase() === normalizedCommandName);
+};
+var getDisabledRawCommand = (composer, searchSource, text) => {
+  const rawCommand = getCommandByName(searchSource, getRawCommandName(text));
+  if (rawCommand && composer.isCommandDisabled(rawCommand)) {
+    return rawCommand;
   }
-  enableFilter(filterKey) {
-    const config = this.filterConfig.getLatestValue();
-    if (config[filterKey]) {
-      this.filterConfig.partialNext({
-        [filterKey]: {
-          ...config[filterKey],
-          enabled: true
+};
+var createCompositionValidationMiddleware = (composer) => {
+  const commandSearchSource = new CommandSearchSource(composer.channel);
+  return {
+    id: "stream-io/message-composer-middleware/data-validation",
+    handlers: {
+      compose: async ({
+        state,
+        discard,
+        forward
+      }) => {
+        const { maxLengthOnSend } = composer.config.text ?? {};
+        const inputText = state.message.text ?? "";
+        const disabledRawCommand = getDisabledRawCommand(
+          composer,
+          commandSearchSource,
+          inputText
+        );
+        if (disabledRawCommand) {
+          notifyCommandDisabled(composer, disabledRawCommand);
+          return await discard();
         }
+        const hasExceededMaxLength = typeof maxLengthOnSend === "number" && inputText.length > maxLengthOnSend;
+        if (composer.compositionIsEmpty || hasExceededMaxLength) {
+          return await discard();
+        }
+        return await forward();
+      }
+    }
+  };
+};
+var createDraftCompositionValidationMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/draft-data-validation",
+  handlers: {
+    compose: async ({
+      state,
+      discard,
+      forward
+    }) => {
+      const hasData = !textIsEmpty(state.draft.text ?? "") || state.draft.attachments?.length || state.draft.poll_id || state.draft.quoted_message_id;
+      const shouldCreateDraft = composer.lastChangeOriginIsLocal && hasData;
+      if (!shouldCreateDraft) {
+        return await discard();
+      }
+      return await forward();
+    }
+  }
+});
+
+// src/messageComposer/middleware/messageComposer/linkPreviews.ts
+var createLinkPreviewsCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/link-previews",
+  handlers: {
+    compose: ({
+      state,
+      next,
+      forward
+    }) => {
+      const { linkPreviewsManager } = composer;
+      if (!linkPreviewsManager) return forward();
+      linkPreviewsManager.cancelURLEnrichment();
+      const someLinkPreviewsLoading = linkPreviewsManager.loadingPreviews.length > 0;
+      const someLinkPreviewsDismissed = linkPreviewsManager.dismissedPreviews.length > 0;
+      const linkPreviews = linkPreviewsManager.loadingPreviews.length > 0 ? [] : linkPreviewsManager.loadedPreviews.map(
+        (preview) => LinkPreviewsManager.getPreviewData(preview)
+      );
+      const attachments = (state.message.attachments ?? []).concat(
+        linkPreviews
+      );
+      if (!attachments.length) return forward();
+      const sendOptions = { ...state.sendOptions };
+      const skip_enrich_url = !someLinkPreviewsLoading && linkPreviews.length > 0 || someLinkPreviewsDismissed;
+      if (skip_enrich_url) {
+        sendOptions.skip_enrich_url = true;
+      }
+      return next({
+        ...state,
+        message: {
+          ...state.message,
+          attachments
+        },
+        localMessage: {
+          ...state.localMessage,
+          attachments
+        },
+        sendOptions
       });
     }
   }
-  disableFilter(filterKey) {
-    const config = this.filterConfig.getLatestValue();
-    if (config[filterKey]) {
-      this.filterConfig.partialNext({
-        [filterKey]: {
-          ...config[filterKey],
-          enabled: false
+});
+var createDraftLinkPreviewsCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/draft-link-previews",
+  handlers: {
+    compose: ({
+      state,
+      next,
+      forward
+    }) => {
+      const { linkPreviewsManager } = composer;
+      if (!linkPreviewsManager) return forward();
+      linkPreviewsManager.cancelURLEnrichment();
+      const linkPreviews = linkPreviewsManager.loadedPreviews.map(
+        (preview) => LinkPreviewsManager.getPreviewData(preview)
+      );
+      if (!linkPreviews.length) return forward();
+      return next({
+        ...state,
+        draft: {
+          ...state.draft,
+          attachments: (state.draft.attachments ?? []).concat(linkPreviews)
         }
       });
     }
   }
-  updateContext(newContext) {
-    this.context.partialNext(newContext);
-  }
-  buildFilters(params) {
-    const filters = {
-      ...params?.baseFilters ?? {}
-    };
-    const filterConfig = this.filterConfig.getLatestValue();
-    for (const key in filterConfig) {
-      const configItem = filterConfig[key];
-      if (!configItem?.enabled) continue;
-      const generated = configItem.generate({
-        ...this.context.getLatestValue(),
-        ...params?.context ?? {}
-      });
-      if (generated) Object.assign(filters, generated);
-    }
-    return filters;
-  }
-};
+});
 
-// src/pagination/ReminderPaginator.ts
-var ReminderPaginator = class extends BasePaginator {
-  constructor(client, options) {
-    super(options);
-    this.query = async ({
-      direction
+// src/messageComposer/middleware/messageComposer/textComposer.ts
+var createTextComposerCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/text-composition",
+  handlers: {
+    compose: ({
+      state,
+      next,
+      forward
     }) => {
-      const cursor = this.cursor?.[direction];
-      const {
-        reminders: items,
-        next,
-        prev
-      } = await this.client.queryReminders({
-        filter: this.filters,
-        sort: this.sort,
-        limit: this.pageSize,
-        [direction]: cursor
+      if (!composer.textComposer) return forward();
+      const { mentionedUsers, text } = composer.textComposer;
+      const mentioned_users = Array.from(
+        new Set(
+          mentionedUsers.filter(
+            ({ id, name }) => text.includes(`@${id}`) || text.includes(`@${name}`)
+          )
+        )
+      );
+      if (!text && mentioned_users.length === 0) return forward();
+      return next({
+        ...state,
+        localMessage: {
+          ...state.localMessage,
+          mentioned_users,
+          text
+        },
+        message: {
+          ...state.message,
+          mentioned_users: mentioned_users.map((u) => u.id),
+          text
+        }
       });
-      return { items, next, prev };
-    };
-    this.filterQueryResults = (items) => items;
-    this.client = client;
-  }
-  get filters() {
-    return this._filters;
-  }
-  get sort() {
-    return this._sort;
-  }
-  set filters(filters) {
-    this._filters = filters;
-    this.resetState();
-  }
-  set sort(sort) {
-    this._sort = sort;
-    this.resetState();
+    }
   }
-};
-
-// src/search/UserSearchSource.ts
-var UserSearchSource = class extends BaseSearchSource {
-  constructor(client, options, filterBuilderOptions = {}) {
-    super(options);
-    this.type = "users";
-    this.client = client;
-    this.filterBuilder = new FilterBuilder({
-      initialFilterConfig: {
-        $or: {
-          enabled: true,
-          generate: ({ searchQuery }) => searchQuery ? {
-            $or: [
-              { id: { $autocomplete: searchQuery } },
-              { name: { $autocomplete: searchQuery } }
-            ]
-          } : null
+});
+var createDraftTextComposerCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/draft-text-composition",
+  handlers: {
+    compose: ({
+      state,
+      next,
+      forward
+    }) => {
+      if (!composer.textComposer) return forward();
+      const { maxLengthOnSend } = composer.config.text ?? {};
+      const { mentionedUsers, text: inputText } = composer.textComposer;
+      const mentioned_users = mentionedUsers.length ? Array.from(
+        new Set(
+          mentionedUsers.filter(
+            ({ id, name }) => inputText.includes(`@${id}`) || inputText.includes(`@${name}`)
+          )
+        )
+      ) : void 0;
+      const text = typeof maxLengthOnSend === "number" && inputText.length > maxLengthOnSend ? inputText.slice(0, maxLengthOnSend) : inputText;
+      return next({
+        ...state,
+        draft: {
+          ...state.draft,
+          mentioned_users: mentioned_users?.map((u) => u.id),
+          text
         }
-      },
-      ...filterBuilderOptions
-    });
-  }
-  async query(searchQuery) {
-    const filters = this.filterBuilder.buildFilters({
-      baseFilters: this.filters,
-      context: { searchQuery }
-    });
-    const sort = { id: 1, ...this.sort };
-    const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const { users } = await this.client.queryUsers(filters, sort, options);
-    return { items: users };
-  }
-  filterQueryResults(items) {
-    return items.filter((u) => u.id !== this.client.user?.id);
-  }
-};
-
-// src/search/ChannelSearchSource.ts
-var ChannelSearchSource = class extends BaseSearchSource {
-  constructor(client, options, filterBuilderOptions = {}) {
-    super(options);
-    this.type = "channels";
-    this.client = client;
-    this.filterBuilder = new FilterBuilder({
-      ...filterBuilderOptions,
-      initialFilterConfig: {
-        name: {
-          enabled: true,
-          generate: ({ searchQuery }) => searchQuery ? { name: { $autocomplete: searchQuery } } : null
-        },
-        ...filterBuilderOptions.initialFilterConfig
-      }
-    });
-  }
-  async query(searchQuery) {
-    const filters = this.filterBuilder.buildFilters({
-      baseFilters: {
-        ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
-        ...this.filters
-      },
-      context: { searchQuery }
-    });
-    const sort = this.sort ?? {};
-    const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const items = await this.client.queryChannels(filters, sort, options);
-    return { items };
-  }
-  filterQueryResults(items) {
-    return items;
+      });
+    }
   }
-};
+});
 
-// src/search/MessageSearchSource.ts
-var MessageSearchSource = class extends BaseSearchSource {
-  constructor(client, options, filterBuilderOptions) {
-    super(options);
-    this.type = "messages";
-    this.client = client;
-    this.messageSearchChannelFilterBuilder = new FilterBuilder(filterBuilderOptions?.messageSearchChannel);
-    this.messageSearchFilterBuilder = new FilterBuilder({
-      ...filterBuilderOptions?.messageSearch,
-      initialFilterConfig: {
-        text: {
-          enabled: true,
-          generate: ({ searchQuery }) => searchQuery ? { text: searchQuery } : null
-        },
-        ...filterBuilderOptions?.messageSearch?.initialFilterConfig
+// src/messageComposer/middleware/messageComposer/messageComposerState.ts
+var createMessageComposerStateCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/own-state",
+  handlers: {
+    compose: ({
+      state,
+      next
+    }) => {
+      const payload = {};
+      if (composer.quotedMessage) {
+        payload.quoted_message_id = composer.quotedMessage.id;
       }
-    });
-    this.channelQueryFilterBuilder = new FilterBuilder({
-      ...filterBuilderOptions?.channelQuery,
-      initialFilterConfig: {
-        cid: {
-          enabled: true,
-          generate: ({ cids }) => cids ? { cid: { $in: cids } } : null
-        },
-        ...filterBuilderOptions?.channelQuery?.initialFilterConfig
+      if (composer.pollId) {
+        payload.poll_id = composer.pollId;
       }
-    });
+      if (composer.showReplyInChannel) {
+        payload.show_in_channel = true;
+      }
+      return next({
+        ...state,
+        localMessage: {
+          ...state.localMessage,
+          ...payload,
+          quoted_message: composer.quotedMessage ?? void 0
+        },
+        message: {
+          ...state.message,
+          ...payload
+        }
+      });
+    }
   }
-  async query(searchQuery) {
-    if (!this.client.userID || !searchQuery || this.next === null) return { items: [] };
-    const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
-      baseFilters: {
-        ...this.client.userID ? { members: { $in: [this.client.userID] } } : {},
-        ...this.messageSearchChannelFilters
-      },
-      context: { searchQuery }
-    });
-    const messageFilters = this.messageSearchFilterBuilder.buildFilters({
-      baseFilters: {
-        type: "regular",
-        ...this.messageSearchFilters
-      },
-      context: { searchQuery }
-    });
-    const sort = {
-      created_at: -1,
-      ...this.messageSearchSort
-    };
-    const options = {
-      limit: this.pageSize,
-      next: this.next,
-      sort
-    };
-    const { next, results } = await this.client.search(
-      channelFilters,
-      messageFilters,
-      options
-    );
-    const items = results.map(({ message }) => message);
-    const cids = Array.from(
-      items.reduce((acc, message) => {
-        if (message.cid && !this.client.activeChannels[message.cid]) acc.add(message.cid);
-        return acc;
-      }, /* @__PURE__ */ new Set())
-    );
-    if (cids.length > 0) {
-      const channelQueryFilters = this.channelQueryFilterBuilder.buildFilters({
-        baseFilters: this.channelQueryFilters,
-        context: { cids }
+});
+var createDraftMessageComposerStateCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/draft-own-state",
+  handlers: {
+    compose: ({
+      state,
+      next
+    }) => {
+      const payload = {};
+      if (composer.quotedMessage) {
+        payload.quoted_message_id = composer.quotedMessage.id;
+      }
+      if (composer.pollId) {
+        payload.poll_id = composer.pollId;
+      }
+      if (composer.showReplyInChannel) {
+        payload.show_in_channel = true;
+      }
+      return next({
+        ...state,
+        draft: {
+          ...state.draft,
+          ...payload
+        }
       });
-      await this.client.queryChannels(
-        channelQueryFilters,
-        {
-          last_message_at: -1,
-          ...this.channelQuerySort
-        },
-        this.channelQueryOptions
-      );
     }
-    return { items, next };
   }
-  filterQueryResults(items) {
-    return items;
+});
+
+// src/messageComposer/middleware/messageComposer/userDataInjection.ts
+var createUserDataInjectionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/user-data-injection",
+  handlers: {
+    compose: ({
+      state,
+      next,
+      forward
+    }) => {
+      if (!composer.client.user) {
+        return forward();
+      }
+      const { channel_mutes, devices, mutes, ...messageUser } = composer.client.user;
+      return next({
+        ...state,
+        localMessage: {
+          ...state.localMessage,
+          user: messageUser,
+          user_id: messageUser.id
+        }
+      });
+    }
   }
-};
+});
 
-// src/messageComposer/middleware/textComposer/textMiddlewareUtils.ts
-var getTriggerCharWithToken = ({
-  trigger,
-  text,
-  isCommand = false,
-  acceptTrailingSpaces = true
-}) => {
-  const escapedTrigger = escapeRegExp(trigger);
-  const triggerNorWhitespace = `[^\\s${escapedTrigger}]*`;
-  const match = text.match(
-    new RegExp(
-      isCommand ? `^[${escapedTrigger}]${triggerNorWhitespace}$` : acceptTrailingSpaces ? `(?!^|\\W)?[${escapedTrigger}]${triggerNorWhitespace}\\s?${triggerNorWhitespace}$` : `(?!^|\\W)?[${escapedTrigger}]${triggerNorWhitespace}$`,
-      "g"
-    )
-  );
-  return match && match[match.length - 1].trim();
-};
-var getCompleteCommandInString = (text) => {
-  const match = text.match(/^\/(\S+)\s+.*/);
-  const commandName = match && match[1];
-  return commandName;
+// src/messageComposer/middleware/messageComposer/pollOnly.ts
+var pollLocalMessageNullifiedFields = {
+  attachments: [],
+  mentioned_users: [],
+  parent_id: void 0,
+  quoted_message: void 0,
+  text: ""
 };
-var insertItemWithTrigger = ({
-  insertText,
-  selection,
-  text,
-  trigger
-}) => {
-  const beforeCursor = text.slice(0, selection.end);
-  const afterCursor = text.slice(selection.end);
-  const lastIndex = beforeCursor.lastIndexOf(trigger);
-  const newText = beforeCursor.slice(0, lastIndex) + insertText + afterCursor;
-  return {
-    text: newText,
-    selection: {
-      start: lastIndex + insertText.length,
-      end: lastIndex + insertText.length
+var createPollOnlyCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/poll-only",
+  handlers: {
+    compose: ({
+      state,
+      complete,
+      forward
+    }) => {
+      const pollId = composer.pollId;
+      const isEditingMessage = !!composer.editedMessage;
+      const isComposingThreadReply = !!composer.threadId;
+      if (!pollId || isComposingThreadReply || isEditingMessage) return forward();
+      return complete({
+        ...state,
+        localMessage: {
+          ...state.localMessage,
+          ...pollLocalMessageNullifiedFields,
+          poll_id: pollId
+        },
+        message: {
+          id: state.localMessage.id,
+          poll_id: pollId
+        }
+      });
+    }
+  }
+});
+
+// src/messageComposer/middleware/messageComposer/sharedLocation.ts
+var createSharedLocationCompositionMiddleware = (composer) => ({
+  id: "stream-io/message-composer-middleware/shared-location",
+  handlers: {
+    compose: ({
+      state,
+      next,
+      forward
+    }) => {
+      const { locationComposer } = composer;
+      const location = locationComposer.validLocation;
+      if (!locationComposer || !location || !composer.client.user) return forward();
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      return next({
+        ...state,
+        localMessage: {
+          ...state.localMessage,
+          shared_location: {
+            ...location,
+            channel_cid: composer.channel.cid,
+            created_at: timestamp,
+            updated_at: timestamp,
+            user_id: composer.client.user.id
+          }
+        },
+        message: {
+          ...state.message,
+          shared_location: location
+        }
+      });
     }
-  };
-};
-var replaceWordWithEntity = async ({
-  caretPosition,
-  getEntityString,
-  text
-}) => {
-  const lastWordRegex = /([^\s]+)(\s*)$/;
-  const match = lastWordRegex.exec(text.slice(0, caretPosition));
-  if (!match) return text;
-  const lastWord = match[1];
-  if (!lastWord) return text;
-  const spaces = match[2];
-  const newWord = await getEntityString(lastWord);
-  if (newWord == null) return text;
-  const textBeforeWord = text.slice(0, caretPosition - match[0].length);
-  const textAfterCaret = text.slice(caretPosition, -1);
-  return textBeforeWord + newWord + spaces + textAfterCaret;
-};
-function escapeRegExp(text) {
-  return text.replace(/[-[\]{}()*+?.,/\\^$|#]/g, "\\$&");
-}
-var getTokenizedSuggestionDisplayName = ({
-  displayName,
-  searchToken
-}) => ({
-  tokenizedDisplayName: {
-    token: searchToken,
-    parts: searchToken ? displayName.split(new RegExp(`(${escapeRegExp(searchToken)})`, "gi")).filter(Boolean) : [displayName]
   }
 });
 
-// src/messageComposer/middleware/textComposer/commands.ts
-var CommandSearchSource = class extends BaseSearchSourceSync {
-  constructor(channel, options) {
-    super(options);
-    this.type = "commands";
-    this.canExecuteQuery = (newSearchString) => {
-      const hasNewSearchQuery = typeof newSearchString !== "undefined";
-      return this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery);
-    };
-    this.channel = channel;
+// src/messageComposer/middleware/messageComposer/MessageComposerMiddlewareExecutor.ts
+var MessageComposerMiddlewareExecutor = class extends MiddlewareExecutor {
+  constructor({ composer }) {
+    super();
+    this.use([
+      createUserDataInjectionMiddleware(composer),
+      createPollOnlyCompositionMiddleware(composer),
+      createTextComposerCompositionMiddleware(composer),
+      createAttachmentsCompositionMiddleware(composer),
+      createLinkPreviewsCompositionMiddleware(composer),
+      createSharedLocationCompositionMiddleware(composer),
+      createMessageComposerStateCompositionMiddleware(composer),
+      createCustomDataCompositionMiddleware(composer),
+      createCompositionValidationMiddleware(composer),
+      createCompositionDataCleanupMiddleware(composer)
+    ]);
   }
-  getStateBeforeFirstQuery(newSearchString) {
-    const newState = super.getStateBeforeFirstQuery(newSearchString);
-    const { items } = this.state.getLatestValue();
-    return {
-      ...newState,
-      items
-      // preserve items to avoid flickering
-    };
+};
+var MessageDraftComposerMiddlewareExecutor = class extends MiddlewareExecutor {
+  constructor({ composer }) {
+    super();
+    this.use([
+      createDraftTextComposerCompositionMiddleware(composer),
+      createDraftAttachmentsCompositionMiddleware(composer),
+      createDraftLinkPreviewsCompositionMiddleware(composer),
+      createDraftMessageComposerStateCompositionMiddleware(composer),
+      createDraftCustomDataCompositionMiddleware(composer),
+      createDraftCompositionValidationMiddleware(composer)
+    ]);
   }
-  query(searchQuery) {
-    const channelConfig = this.channel.getConfig();
-    const commands = channelConfig?.commands || [];
-    const selectedCommands = commands.filter(
-      (command) => !!(command.name && command.name.toLowerCase().indexOf(searchQuery.toLowerCase()) !== -1)
-    );
-    selectedCommands.sort((a, b) => {
-      let nameA = a.name?.toLowerCase();
-      let nameB = b.name?.toLowerCase();
-      if (nameA?.indexOf(searchQuery) === 0) {
-        nameA = `0${nameA}`;
-      }
-      if (nameB?.indexOf(searchQuery) === 0) {
-        nameB = `0${nameB}`;
+};
+
+// src/messageComposer/middleware/messageComposer/commandInjection.ts
+var createCommandInjectionMiddleware = (composer) => ({
+  handlers: {
+    compose: ({
+      forward,
+      next,
+      state
+    }) => {
+      const command = composer.textComposer.command;
+      if (!command) {
+        return forward();
       }
-      if (nameA != null && nameB != null) {
-        if (nameA < nameB) {
-          return -1;
+      const { text } = state.localMessage;
+      const injection = `/${command?.name}`;
+      const enrichedText = `${injection} ${text}`;
+      return next({
+        ...state,
+        localMessage: {
+          ...state.localMessage,
+          text: enrichedText
+        },
+        message: {
+          ...state.message,
+          text: enrichedText
         }
-        if (nameA > nameB) {
-          return 1;
+      });
+    }
+  },
+  id: "stream-io/message-composer-middleware/command-string-injection"
+});
+var createDraftCommandInjectionMiddleware = (composer) => ({
+  handlers: {
+    compose: ({
+      forward,
+      next,
+      state
+    }) => {
+      const command = composer.textComposer.command;
+      if (!command) {
+        return forward();
+      }
+      const { text } = state.draft;
+      const injection = `/${command?.name}`;
+      const enrichedText = `${injection} ${text}`;
+      return next({
+        ...state,
+        draft: {
+          ...state.draft,
+          text: enrichedText
         }
+      });
+    }
+  },
+  id: "stream-io/message-composer-middleware/draft-command-string-injection"
+});
+
+// src/messageComposer/middleware/textComposer/activeCommandGuard.ts
+var createActiveCommandGuardMiddleware = () => ({
+  handlers: {
+    onChange: ({ complete, forward, state }) => {
+      if (state.command) {
+        return complete(state);
       }
-      return 0;
-    });
-    return {
-      items: selectedCommands.map((c) => ({ ...c, id: c.name })),
-      next: null
-    };
-  }
-  filterQueryResults(items) {
-    return items;
-  }
+      return forward();
+    },
+    onSuggestionItemSelect: ({ forward }) => forward()
+  },
+  id: "stream-io/text-composer/active-command-guard"
+});
+
+// src/messageComposer/middleware/textComposer/commandEffects.ts
+var emptyCommandStateToRestore = {
+  selection: { start: 0, end: 0 },
+  text: ""
 };
-var DEFAULT_OPTIONS = { minChars: 1, trigger: "/" };
-var createCommandsMiddleware = (channel, options) => {
-  const finalOptions = mergeWith(DEFAULT_OPTIONS, options ?? {});
-  let searchSource = new CommandSearchSource(channel);
-  if (options?.searchSource) {
-    searchSource = options.searchSource;
-    searchSource.resetState();
-  }
-  searchSource.activate();
-  return {
-    id: "stream-io/text-composer/commands-middleware",
-    handlers: {
-      onChange: ({ state, next, complete, forward }) => {
-        if (!state.selection) return forward();
-        const finalText = state.text.slice(0, state.selection.end);
-        const commandName = getCompleteCommandInString(finalText);
-        if (commandName) {
-          const command = searchSource?.query(commandName).items[0];
-          if (command) {
-            return next({
-              ...state,
-              command,
-              suggestions: void 0
-            });
-          }
-        }
-        const triggerWithToken = getTriggerCharWithToken({
-          trigger: finalOptions.trigger,
-          text: finalText,
-          acceptTrailingSpaces: false,
-          isCommand: true
-        });
-        const newSearchTriggerred = triggerWithToken && triggerWithToken.length === finalOptions.minChars;
-        if (newSearchTriggerred) {
-          searchSource.resetStateAndActivate();
-        }
-        const triggerWasRemoved = !triggerWithToken || triggerWithToken.length < finalOptions.minChars;
-        if (triggerWasRemoved) {
-          const hasStaleSuggestions = state.suggestions?.trigger === finalOptions.trigger;
-          const newState = { ...state };
-          if (hasStaleSuggestions) {
-            delete newState.suggestions;
-          }
-          return next(newState);
-        }
-        return complete({
-          ...state,
-          command: null,
-          suggestions: {
-            query: triggerWithToken.slice(1),
-            searchSource,
-            trigger: finalOptions.trigger
-          }
-        });
-      },
-      onSuggestionItemSelect: ({ state, next, forward }) => {
-        const { selectedSuggestion } = state.change ?? {};
-        if (!selectedSuggestion || state.suggestions?.trigger !== finalOptions.trigger)
-          return forward();
-        searchSource.resetStateAndActivate();
-        return next({
-          ...state,
-          ...insertItemWithTrigger({
-            insertText: `/${selectedSuggestion.name} `,
-            selection: state.selection,
-            text: state.text,
-            trigger: finalOptions.trigger
-          }),
-          command: selectedSuggestion,
-          suggestions: void 0
-        });
+var createCommandActivationEffect = (command) => ({
+  command,
+  stateToRestore: emptyCommandStateToRestore,
+  type: "command.activate"
+});
+var isCommandResponse = (suggestion) => typeof suggestion?.name === "string";
+var createCommandEffectsMiddleware = () => ({
+  handlers: {
+    onChange: ({ forward }) => forward(),
+    onSuggestionItemSelect: ({ state, next, forward }) => {
+      const { selectedSuggestion } = state.change ?? {};
+      if (!isCommandResponse(selectedSuggestion) || !state.command || state.command.name !== selectedSuggestion.name) {
+        return forward();
       }
+      return next({
+        ...state,
+        effects: [...state.effects ?? [], createCommandActivationEffect(state.command)]
+      });
     }
-  };
-};
+  },
+  id: "stream-io/text-composer/command-effects-middleware"
+});
 
 // src/messageComposer/middleware/textComposer/commandStringExtraction.ts
-var stripCommandFromText = (text, commandName) => text.replace(new RegExp(`^${escapeRegExp(`/${commandName}`)}\\s*`), "");
 var createCommandStringExtractionMiddleware = () => ({
   handlers: {
     onChange: ({ complete, forward, state }) => {
@@ -6124,7 +6323,10 @@ var TextComposerMiddlewareExecutor = class extends MiddlewareExecutor {
     this.use([
       createTextComposerPreValidationMiddleware(composer),
       createMentionsMiddleware(composer.channel),
-      createCommandsMiddleware(composer.channel)
+      createCommandsMiddleware(composer.channel, {
+        composer
+      }),
+      createCommandEffectsMiddleware()
     ]);
   }
   async execute({
@@ -6173,6 +6375,10 @@ var TextComposer = class {
     this.initState = ({ message } = {}) => {
       this.state.next(initState5({ composer: this.composer, message }));
     };
+    this.getSnapshot = (state = this.state.getLatestValue()) => state;
+    this.restoreSnapshot = (snapshot) => {
+      this.state.next(snapshot);
+    };
     this.upsertMentionedUser = (user) => {
       const mentionedUsers = [...this.mentionedUsers];
       const existingUserIndex = mentionedUsers.findIndex((u) => u.id === user.id);
@@ -6193,8 +6399,27 @@ var TextComposer = class {
       this.state.partialNext({ mentionedUsers });
     };
     this.setCommand = (command) => {
-      if (command?.name === this.command?.name) return;
-      this.state.partialNext({ command });
+      if (!command) {
+        this.clearCommand();
+        return;
+      }
+      if (command.name === this.command?.name) return;
+      if (this.composer.isCommandDisabled(command)) return;
+      const stateToRestore = {
+        command: null
+      };
+      this.commitState({
+        ...this.state.getLatestValue(),
+        command,
+        effects: [
+          {
+            command,
+            stateToRestore,
+            type: "command.activate"
+          }
+        ],
+        suggestions: void 0
+      });
     };
     this.setText = (text) => {
       if (!this.enabled || text === this.text) return;
@@ -6261,6 +6486,12 @@ var TextComposer = class {
       this.state.partialNext({ suggestions: void 0 });
     };
     // --- END STATE API ---
+    this.commitState = (state) => {
+      const { change, effects, ...nextState } = state;
+      void change;
+      this.state.next(nextState);
+      this.composer.applyEffects(effects);
+    };
     // --- START TEXT PROCESSING ----
     this.handleChange = async ({
       text,
@@ -6276,7 +6507,7 @@ var TextComposer = class {
         }
       });
       if (output.status === "discard") return;
-      this.state.next(output.state);
+      this.commitState(output.state);
       if (this.config.publishTypingEvents && text) {
         logChatPromiseExecution(
           this.channel.keystroke(this.composer.threadId ?? void 0),
@@ -6297,7 +6528,7 @@ var TextComposer = class {
         }
       });
       if (output?.status === "discard") return;
-      this.state.next(output.state);
+      this.commitState(output.state);
     };
     this.composer = composer;
     this.state = new StateStore(initState5({ composer, message }));
@@ -6367,7 +6598,12 @@ var TextComposer = class {
     this.state.partialNext({ mentionedUsers: users });
   }
   clearCommand() {
-    this.state.partialNext({ command: null });
+    if (!this.command) return;
+    this.commitState({
+      ...this.state.getLatestValue(),
+      command: null,
+      effects: [{ type: "command.clear" }]
+    });
   }
   // --- END TEXT PROCESSING ----
 };
@@ -6858,15 +7094,28 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     client
   }) {
     super();
+    this.snapshots = [];
     this.setEditedMessage = (editedMessage) => {
       this.state.partialNext({ editedMessage: editedMessage ?? null });
+      if (editedMessage) {
+        this.textComposer.clearCommand();
+      }
+    };
+    this.getCommandDisabledReason = (command) => {
+      if (this.editedMessage) return "editing";
+      if (this.quotedMessage && (command.set === "moderation_set" || command.name === "moderation_set")) {
+        return "quoted_message";
+      }
+      return void 0;
     };
+    this.isCommandDisabled = (command) => !!this.getCommandDisabledReason(command);
     this.refreshId = () => {
       this.state.partialNext({ id: _MessageComposer.generateId() });
     };
     this.initState = ({
       composition
     } = {}) => {
+      this.clearSnapshots();
       this.editingAuditState.partialNext(this.initEditingAuditState(composition));
       const message = typeof composition === "undefined" ? composition : compositionIsDraftResponse(composition) ? composition.message : formatMessage(composition);
       this.attachmentManager.initState({ message });
@@ -6896,6 +7145,36 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
       }
     };
     this.initEditingAuditState = (composition) => initEditingAuditState(composition);
+    this.clearSnapshots = () => {
+      this.snapshots = [];
+    };
+    this.getSnapshot = () => ({
+      attachmentManager: this.attachmentManager.getSnapshot(),
+      customDataManager: this.customDataManager.getSnapshot(),
+      linkPreviewsManager: this.linkPreviewsManager.getSnapshot(),
+      locationComposer: this.locationComposer.getSnapshot(),
+      pollComposer: this.pollComposer.getSnapshot(),
+      textComposer: this.textComposer.getSnapshot()
+    });
+    this.restoreSnapshot = (snapshot) => {
+      this.attachmentManager.restoreSnapshot(snapshot.attachmentManager);
+      this.linkPreviewsManager.restoreSnapshot(snapshot.linkPreviewsManager);
+      this.locationComposer.restoreSnapshot(snapshot.locationComposer);
+      this.pollComposer.restoreSnapshot(snapshot.pollComposer);
+      this.customDataManager.restoreSnapshot(snapshot.customDataManager);
+      this.textComposer.restoreSnapshot(snapshot.textComposer);
+    };
+    this.captureSnapshot = (snapshot = this.getSnapshot()) => {
+      if (this.snapshots.length) return;
+      this.snapshots.push(snapshot);
+    };
+    this.popSnapshot = () => this.snapshots.pop();
+    this.registerEffectHandler = (type, handler) => {
+      this.effectHandlers.registerEffectHandler(type, handler);
+    };
+    this.applyEffects = (effects = []) => {
+      this.effectHandlers.applyEffects(effects);
+    };
     this.registerDraftEventSubscriptions = () => {
       const unsubscribeDraftUpdated = this.subscribeDraftUpdated();
       const unsubscribeDraftDeleted = this.subscribeDraftDeleted();
@@ -7075,6 +7354,10 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     };
     this.setQuotedMessage = (quotedMessage) => {
       this.state.partialNext({ quotedMessage });
+      const activeCommand = this.textComposer.command;
+      if (quotedMessage && activeCommand && this.isCommandDisabled(activeCommand)) {
+        this.textComposer.clearCommand();
+      }
     };
     this.toggleShowReplyInChannel = () => {
       this.state.partialNext({ showReplyInChannel: !this.showReplyInChannel });
@@ -7309,6 +7592,7 @@ var _MessageComposer = class _MessageComposer extends WithSubscriptions {
     this.draftCompositionMiddlewareExecutor = new MessageDraftComposerMiddlewareExecutor({
       composer: this
     });
+    this.effectHandlers = new MessageComposerEffectHandlers({ composer: this });
   }
   static evaluateContextType(compositionContext) {
     if (compositionContext instanceof Channel) {
@@ -9983,8 +10267,9 @@ var StableWSConnection = class {
     this.onmessage = (wsID, event) => {
       if (this.wsID !== wsID) return;
       this._log("onmessage() - onmessage callback", { event, wsID });
-      const data = typeof event.data === "string" ? JSON.parse(event.data) : null;
-      if (!this.isResolved && data) {
+      if (typeof event.data !== "string") return;
+      const data = JSON.parse(event.data);
+      if (!this.isResolved) {
         this.isResolved = true;
         if (data.error) {
           this.rejectPromise?.(this._errorFromWSEvent(data, false));
@@ -9994,10 +10279,10 @@ var StableWSConnection = class {
         this._setHealth(true);
       }
       this.lastEvent = /* @__PURE__ */ new Date();
-      if (data && data.type === "health.check") {
+      if (data.type === "health.check") {
         this.scheduleNextPing();
       }
-      this.client.handleEvent(event);
+      this.client.dispatchEvent(data);
       this.scheduleConnectionCheck();
     };
     this.onclose = (wsID, event) => {
@@ -13100,11 +13385,6 @@ var StreamChat = class _StreamChat {
         method: `handleEvent;${event.type}`
       });
     };
-    this.handleEvent = (messageEvent) => {
-      const jsonString = messageEvent.data;
-      const event = JSON.parse(jsonString);
-      this.dispatchEvent(event);
-    };
     /**
      * Updates the members, watchers and read references of the currently active channels that contain this user
      *
@@ -15192,7 +15472,7 @@ var StreamChat = class _StreamChat {
     if (this.userAgent) {
       return this.userAgent;
     }
-    const version = "9.42.3";
+    const version = "9.43.1";
     const clientBundle = "browser-esm";
     let userAgentString = "";
     if (this.sdkIdentifier) {
@@ -17895,6 +18175,7 @@ export {
   createActiveCommandGuardMiddleware,
   createAttachmentsCompositionMiddleware,
   createBlockedAttachmentUploadNotificationMiddleware,
+  createCommandEffectsMiddleware,
   createCommandInjectionMiddleware,
   createCommandStringExtractionMiddleware,
   createCommandsMiddleware,
@@ -17924,13 +18205,11 @@ export {
   defaultPollFieldChangeEventValidators,
   encodeBase64,
   ensureIsLocalAttachment,
-  escapeRegExp,
   extractPollData,
   extractPollEnrichedData,
   formatMessage,
   generateFileName,
   getAttachmentTypeFromMimeType,
-  getCompleteCommandInString,
   getExtensionFromMimeType,
   getTokenizedSuggestionDisplayName,
   getTriggerCharWithToken,