@stream-io/feeds-client 0.3.51 → 1.1.0

package/dist/{feeds-client-B4zeBggL.js → feeds-client-C1c6lcS3.js}

@@ -2,6 +2,7 @@
 const stateStore = require("@stream-io/state-store");
 const loggerInternal = require("@stream-io/logger");
 const axiosImport = require("axios");
+const filter = require("@stream-io/filter");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -1140,6 +1141,12 @@ decoders.QueryBookmarksResponse = (input) => {
   };
   return decode(typeMappings, input);
 };
+decoders.QueryCollectionsResponse = (input) => {
+  const typeMappings = {
+    collections: { type: "CollectionResponse", isSingle: false }
+  };
+  return decode(typeMappings, input);
+};
 decoders.QueryCommentReactionsResponse = (input) => {
   const typeMappings = {
     reactions: { type: "FeedsReactionResponse", isSingle: false }
@@ -1714,6 +1721,21 @@ class FeedsApi {
     decoders.DeleteActivitiesResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
+  async trackActivityMetrics(request) {
+    const body = {
+      events: request?.events
+    };
+    const response = await this.apiClient.sendRequest(
+      "POST",
+      "/api/v2/feeds/activities/metrics/track",
+      void 0,
+      void 0,
+      body,
+      "application/json"
+    );
+    decoders.TrackActivityMetricsResponse?.(response.body);
+    return { ...response.body, metadata: response.metadata };
+  }
   async queryActivities(request) {
     const body = {
       enrich_own_fields: request?.enrich_own_fields,
@@ -2126,6 +2148,25 @@ class FeedsApi {
     decoders.CreateCollectionsResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
+  async queryCollections(request) {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter
+    };
+    const response = await this.apiClient.sendRequest(
+      "POST",
+      "/api/v2/feeds/collections/query",
+      void 0,
+      void 0,
+      body,
+      "application/json"
+    );
+    decoders.QueryCollectionsResponse?.(response.body);
+    return { ...response.body, metadata: response.metadata };
+  }
   async getComments(request) {
     const queryParams = {
       object_id: request?.object_id,
@@ -2185,6 +2226,7 @@ class FeedsApi {
   async queryComments(request) {
     const body = {
       filter: request?.filter,
+      id_around: request?.id_around,
       limit: request?.limit,
       next: request?.next,
       prev: request?.prev,
@@ -3216,15 +3258,26 @@ class FeedsApi {
     decoders.UpdateUserGroupResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
-  async removeUserGroupMembers(request) {
+  async addUserGroupMembers(request) {
     const pathParams = {
       id: request?.id
     };
-    const response = await this.apiClient.sendRequest("DELETE", "/api/v2/usergroups/{id}/members", pathParams, void 0);
-    decoders.RemoveUserGroupMembersResponse?.(response.body);
+    const body = {
+      member_ids: request?.member_ids,
+      team_id: request?.team_id
+    };
+    const response = await this.apiClient.sendRequest(
+      "POST",
+      "/api/v2/usergroups/{id}/members",
+      pathParams,
+      void 0,
+      body,
+      "application/json"
+    );
+    decoders.AddUserGroupMembersResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
-  async addUserGroupMembers(request) {
+  async removeUserGroupMembers(request) {
     const pathParams = {
       id: request?.id
     };
@@ -3234,13 +3287,13 @@ class FeedsApi {
     };
     const response = await this.apiClient.sendRequest(
       "POST",
-      "/api/v2/usergroups/{id}/members",
+      "/api/v2/usergroups/{id}/members/delete",
       pathParams,
       void 0,
       body,
       "application/json"
     );
-    decoders.AddUserGroupMembersResponse?.(response.body);
+    decoders.RemoveUserGroupMembersResponse?.(response.body);
     return { ...response.body, metadata: response.metadata };
   }
   async queryUsers(request) {
@@ -4128,7 +4181,7 @@ const getRateLimitFromResponseHeader = (response_headers) => {
   };
   return result;
 };
-const version = "0.3.51";
+const version = "1.1.0";
 const axios = axiosImport.default ?? axiosImport;
 class ApiClient {
   constructor(apiKey, tokenManager, connectionIdManager, options) {
@@ -4944,7 +4997,7 @@ const uniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
   });
   return existingArray.concat(filteredArrayToMerge);
 };
-const replaceUniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
+const replaceUniqueArrayMerge = (existingArray, arrayToMerge, getKey, position) => {
   const existingMap = /* @__PURE__ */ new Map();
   (existingArray ?? []).forEach((item) => {
     existingMap.set(getKey(item), item);
@@ -4960,9 +5013,14 @@ const replaceUniqueArrayMerge = (existingArray, arrayToMerge, getKey) => {
       existingMap.delete(getKey(originalItem));
     }
   });
-  existingMap.forEach((item) => {
-    result.push(item);
-  });
+  const newItemsInOrder = arrayToMerge.filter(
+    (item) => existingMap.has(getKey(item))
+  );
+  if (position === "end") {
+    newItemsInOrder.forEach((item) => result.push(item));
+  } else {
+    result.unshift(...newItemsInOrder);
+  }
   return result;
 };
 const Constants = {
@@ -5009,24 +5067,25 @@ function getStateUpdateQueueId(...args) {
   const [data, prefix] = args;
   const toJoin = [prefix];
   switch (prefix) {
+    case "activity-deleted": {
+      return toJoin.concat([data.activity.id]).join("-");
+    }
+    case "activity-pinned":
+    case "activity-unpinned": {
+      return toJoin.concat([data.pinned_activity.activity.id]).join("-");
+    }
     case "activity-updated": {
       return toJoin.concat([data.activity.id]).join("-");
     }
     case "activity-reaction-created":
     case "activity-reaction-deleted":
     case "activity-reaction-updated": {
-      return toJoin.concat([
-        data.activity.id,
-        data.reaction.type
-      ]).join("-");
+      return toJoin.concat([data.activity.id, data.reaction.type]).join("-");
     }
     case "comment-reaction-created":
     case "comment-reaction-deleted":
     case "comment-reaction-updated": {
-      return toJoin.concat([
-        data.comment.id,
-        data.reaction.type
-      ]).join("-");
+      return toJoin.concat([data.comment.id, data.reaction.type]).join("-");
     }
     case "comment-created":
     case "comment-deleted":
@@ -5038,6 +5097,13 @@ function getStateUpdateQueueId(...args) {
     case "follow-updated": {
       return toJoin.concat([data.source_feed.feed, data.target_feed.feed]).join("-");
     }
+    case "feed-member-added":
+    case "feed-member-updated": {
+      return toJoin.concat([data.member.user.id]).join("-");
+    }
+    case "feed-member-removed": {
+      return toJoin.concat([data.member_id]).join("-");
+    }
     default: {
       ensureExhausted(data, "Encountered unknown state update queue prefix.");
     }
@@ -5063,7 +5129,7 @@ function updateEntityInArray({
   updatedEntities[index] = newEntity;
   return { changed: true, entities: updatedEntities };
 }
-const updateStateFollowCreated = (follow, currentState, currentFeedId, connectedUserId) => {
+const updateStateFollowCreated = (follow, currentState, currentFeedId, connectedUserId, hasOwnFields = false) => {
   if (follow.status !== "accepted") {
     return { changed: false, data: currentState };
   }
@@ -5072,7 +5138,12 @@ const updateStateFollowCreated = (follow, currentState, currentFeedId, connected
     newState = {
       ...newState,
       // Update FeedResponse fields, that has the new follower/following count
-      ...follow.source_feed
+      ...follow.source_feed,
+      ...hasOwnFields ? {
+        own_capabilities: follow.source_feed.own_capabilities,
+        own_follows: follow.source_feed.own_follows,
+        own_followings: follow.source_feed.own_followings
+      } : {}
     };
     if (currentState.following !== void 0) {
       newState.following = [follow, ...currentState.following];
@@ -5085,9 +5156,14 @@ const updateStateFollowCreated = (follow, currentState, currentFeedId, connected
     newState = {
       ...newState,
       // Update FeedResponse fields, that has the new follower/following count
-      ...follow.target_feed
-    };
-    if (source.created_by.id === connectedUserId) {
+      ...follow.target_feed,
+      ...hasOwnFields ? {
+        own_capabilities: follow.target_feed.own_capabilities,
+        own_follows: follow.target_feed.own_follows,
+        own_followings: follow.target_feed.own_followings
+      } : {}
+    };
+    if (source.created_by.id === connectedUserId && !hasOwnFields) {
       newState.own_follows = currentState.own_follows ? currentState.own_follows.concat(follow) : [follow];
     }
     if (currentState.followers !== void 0) {
@@ -5096,7 +5172,7 @@ const updateStateFollowCreated = (follow, currentState, currentFeedId, connected
   }
   return { changed: true, data: newState };
 };
-function handleFollowCreated(eventOrResponse, fromWs) {
+function handleFollowCreated(eventOrResponse, fromWs, hasOwnFields = false) {
   const follow = eventOrResponse.follow;
   if (!shouldUpdateState({
     stateUpdateQueueId: getStateUpdateQueueId(follow, "follow-created"),
@@ -5112,7 +5188,8 @@ function handleFollowCreated(eventOrResponse, fromWs) {
     follow,
     this.currentState,
     this.feed,
-    connectedUser?.id
+    connectedUser?.id,
+    hasOwnFields
   );
   if (result.changed) {
     this.state.next(result.data);
@@ -5195,7 +5272,12 @@ function handleFollowUpdated(eventOrResponse, fromWs) {
       newState ?? (newState = {
         ...currentState,
         // Update FeedResponse fields, that has the new follower/following count
-        ...follow.source_feed
+        ...follow.source_feed,
+        ...follow.source_feed.own_capabilities !== void 0 ? {
+          own_capabilities: follow.source_feed.own_capabilities,
+          own_follows: follow.source_feed.own_follows,
+          own_followings: follow.source_feed.own_followings
+        } : {}
       });
       const index = currentState.following?.findIndex(
         (f) => f.target_feed.feed === follow.target_feed.feed
@@ -5212,7 +5294,12 @@ function handleFollowUpdated(eventOrResponse, fromWs) {
       newState ?? (newState = {
         ...currentState,
         // Update FeedResponse fields, that has the new follower/following count
-        ...follow.target_feed
+        ...follow.target_feed,
+        ...follow.target_feed.own_capabilities !== void 0 ? {
+          own_capabilities: follow.target_feed.own_capabilities,
+          own_follows: follow.target_feed.own_follows,
+          own_followings: follow.target_feed.own_followings
+        } : {}
       });
       if (source.created_by.id === connectedUserId && currentState.own_follows) {
         const index2 = currentState.own_follows.findIndex(
@@ -5336,14 +5423,14 @@ function handleCommentUpdated(payload, fromWs) {
   const { comment } = payload;
   const entityId = comment.parent_id ?? comment.object_id;
   if (!shouldUpdateState({
-    stateUpdateQueueId: getStateUpdateQueueId(
-      payload,
-      "comment-updated"
-    ),
+    stateUpdateQueueId: getStateUpdateQueueId(payload, "comment-updated"),
     stateUpdateQueue: this.stateUpdateQueue,
     watch: this.currentState.watch,
     fromWs,
-    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(this, payload)
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      payload
+    )
   })) {
     return;
   }
@@ -5353,7 +5440,10 @@ function handleCommentUpdated(payload, fromWs) {
     const index = this.getCommentIndex(comment, currentState);
     if (index === -1) return currentState;
     const newComments = [...entityState.comments];
-    newComments[index] = comment;
+    newComments[index] = {
+      ...comment,
+      own_reactions: entityState.comments[index].own_reactions
+    };
     return {
       ...currentState,
       comments_by_entity_id: {
@@ -5504,7 +5594,19 @@ function handleCommentReactionUpdated(payload, fromWs) {
     };
   });
 }
-function handleFeedMemberAdded(event) {
+function handleFeedMemberAdded(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "feed-member-added"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   this.state.next((currentState) => {
     let newState;
@@ -5523,7 +5625,19 @@ function handleFeedMemberAdded(event) {
     return newState ?? currentState;
   });
 }
-function handleFeedMemberUpdated(event) {
+function handleFeedMemberUpdated(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "feed-member-updated"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   this.state.next((currentState) => {
     const memberIndex = currentState.members?.findIndex(
@@ -5547,7 +5661,19 @@ function handleFeedMemberUpdated(event) {
     return newState ?? currentState;
   });
 }
-function handleFeedMemberRemoved(event) {
+function handleFeedMemberRemoved(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "feed-member-removed"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   this.state.next((currentState) => {
     let newState;
@@ -5567,6 +5693,9 @@ function handleFeedMemberRemoved(event) {
     return newState ?? currentState;
   });
 }
+const isSameBookmark = (bookmark1, bookmark2) => {
+  return bookmark1.user.id === bookmark2.user.id && bookmark1.activity.id === bookmark2.activity.id && bookmark1.folder?.id === bookmark2.folder?.id && bookmark1.updated_at.getTime() === bookmark2.updated_at.getTime();
+};
 const sharedUpdateActivity$6 = ({
   currentActivity,
   event,
@@ -5574,7 +5703,9 @@ const sharedUpdateActivity$6 = ({
 }) => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
   if (eventBelongsToCurrentUser) {
-    newOwnBookmarks = [...newOwnBookmarks, event.bookmark];
+    newOwnBookmarks = currentActivity.own_bookmarks.filter(
+      (bookmark) => !isSameBookmark(bookmark, event.bookmark)
+    );
   }
   return {
     ...currentActivity,
@@ -5582,18 +5713,20 @@ const sharedUpdateActivity$6 = ({
     own_bookmarks: newOwnBookmarks
   };
 };
-const addBookmarkToActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+const removeBookmarkFromActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: activities,
-  matcher: (activity) => activity.id === event.bookmark.activity.id,
+  matcher: (activity) => activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
   updater: (matchedActivity) => sharedUpdateActivity$6({
     currentActivity: matchedActivity,
     event,
     eventBelongsToCurrentUser
   })
 });
-const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: pinnedActivities,
-  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || pinnedActivity.activity.own_bookmarks.some(
+    (b) => isSameBookmark(b, event.bookmark)
+  )),
   updater: (matchedPinnedActivity) => {
     const newActivity = sharedUpdateActivity$6({
       currentActivity: matchedPinnedActivity.activity,
@@ -5609,7 +5742,7 @@ const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCu
     };
   }
 });
-function handleBookmarkAdded(event) {
+function handleBookmarkDeleted(event) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -5617,12 +5750,12 @@ function handleBookmarkAdded(event) {
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   const eventBelongsToCurrentUser = event.bookmark.user.id === connectedUser?.id;
   const [result1, result2] = [
-    addBookmarkToActivities(
+    removeBookmarkFromActivities(
       event,
       currentActivities,
       eventBelongsToCurrentUser
     ),
-    addBookmarkToPinnedActivities(
+    removeBookmarkFromPinnedActivities(
       event,
       currentPinnedActivities,
       eventBelongsToCurrentUser
@@ -5635,9 +5768,6 @@ function handleBookmarkAdded(event) {
     });
   }
 }
-const isSameBookmark = (bookmark1, bookmark2) => {
-  return bookmark1.user.id === bookmark2.user.id && bookmark1.activity.id === bookmark2.activity.id && bookmark1.folder?.id === bookmark2.folder?.id;
-};
 const sharedUpdateActivity$5 = ({
   currentActivity,
   event,
@@ -5645,9 +5775,7 @@ const sharedUpdateActivity$5 = ({
 }) => {
   let newOwnBookmarks = currentActivity.own_bookmarks;
   if (eventBelongsToCurrentUser) {
-    newOwnBookmarks = currentActivity.own_bookmarks.filter(
-      (bookmark) => !isSameBookmark(bookmark, event.bookmark)
-    );
+    newOwnBookmarks = [...newOwnBookmarks, event.bookmark];
   }
   return {
     ...currentActivity,
@@ -5655,18 +5783,20 @@ const sharedUpdateActivity$5 = ({
     own_bookmarks: newOwnBookmarks
   };
 };
-const removeBookmarkFromActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
+const addBookmarkToActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: activities,
-  matcher: (activity) => activity.id === event.bookmark.activity.id,
+  matcher: (activity) => activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
   updater: (matchedActivity) => sharedUpdateActivity$5({
     currentActivity: matchedActivity,
     event,
     eventBelongsToCurrentUser
   })
 });
-const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
+const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: pinnedActivities,
-  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !pinnedActivity.activity.own_bookmarks.some(
+    (b) => isSameBookmark(b, event.bookmark)
+  )),
   updater: (matchedPinnedActivity) => {
     const newActivity = sharedUpdateActivity$5({
       currentActivity: matchedPinnedActivity.activity,
@@ -5682,7 +5812,7 @@ const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelong
     };
   }
 });
-function handleBookmarkDeleted(event) {
+function handleBookmarkAdded(event) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -5690,12 +5820,12 @@ function handleBookmarkDeleted(event) {
   const { connected_user: connectedUser } = this.client.state.getLatestValue();
   const eventBelongsToCurrentUser = event.bookmark.user.id === connectedUser?.id;
   const [result1, result2] = [
-    removeBookmarkFromActivities(
+    addBookmarkToActivities(
       event,
       currentActivities,
       eventBelongsToCurrentUser
     ),
-    removeBookmarkFromPinnedActivities(
+    addBookmarkToPinnedActivities(
       event,
       currentPinnedActivities,
       eventBelongsToCurrentUser
@@ -5716,7 +5846,7 @@ const sharedUpdateActivity$4 = ({
   let newOwnBookmarks = currentActivity.own_bookmarks;
   if (eventBelongsToCurrentUser) {
     const bookmarkIndex = newOwnBookmarks.findIndex(
-      (bookmark) => isSameBookmark(bookmark, event.bookmark)
+      (bookmark) => bookmark.user.id === event.bookmark.user.id && bookmark.activity.id === event.bookmark.activity.id && bookmark.folder?.id === event.bookmark.folder?.id
     );
     if (bookmarkIndex !== -1) {
       newOwnBookmarks = [...newOwnBookmarks];
@@ -5731,7 +5861,7 @@ const sharedUpdateActivity$4 = ({
 };
 const updateBookmarkInActivities = (event, activities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: activities,
-  matcher: (activity) => activity.id === event.bookmark.activity.id,
+  matcher: (activity) => activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !activity.own_bookmarks.some((b) => isSameBookmark(b, event.bookmark))),
   updater: (matchedActivity) => sharedUpdateActivity$4({
     currentActivity: matchedActivity,
     event,
@@ -5740,7 +5870,9 @@ const updateBookmarkInActivities = (event, activities, eventBelongsToCurrentUser
 });
 const updateBookmarkInPinnedActivities = (event, pinnedActivities, eventBelongsToCurrentUser) => updateEntityInArray({
   entities: pinnedActivities,
-  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id,
+  matcher: (pinnedActivity) => pinnedActivity.activity.id === event.bookmark.activity.id && (!eventBelongsToCurrentUser || !pinnedActivity.activity.own_bookmarks.some(
+    (b) => isSameBookmark(b, event.bookmark)
+  )),
   updater: (matchedPinnedActivity) => {
     const newActivity = sharedUpdateActivity$4({
       currentActivity: matchedPinnedActivity.activity,
@@ -5782,7 +5914,13 @@ function handleBookmarkUpdated(event) {
     });
   }
 }
-function addActivitiesToState(newActivities, activities, position, { fromWebSocket } = { fromWebSocket: false }) {
+function addActivitiesToState(newActivities, activities, position, {
+  hasOwnFields,
+  backfillOwnFields
+} = {
+  hasOwnFields: true,
+  backfillOwnFields: true
+}) {
   if (activities === void 0) {
     return {
       changed: false,
@@ -5805,23 +5943,31 @@ function addActivitiesToState(newActivities, activities, position, { fromWebSock
       ...activities,
       ...position === "end" ? newActivitiesDeduplicated : []
     ];
-    this.newActivitiesAdded(newActivitiesDeduplicated, { fromWebSocket });
+    this.activitiesAddedOrUpdated(newActivitiesDeduplicated, {
+      hasOwnFields,
+      backfillOwnFields
+    });
     result = { changed: true, activities: updatedActivities };
   }
   return result;
 }
 function handleActivityAdded(event) {
-  if (this.activityAddedEventFilter) {
-    if (!this.activityAddedEventFilter(event)) {
-      return;
-    }
+  const currentUser = this.client.state.getLatestValue().connected_user;
+  const decision = this.resolveNewActivityDecision(
+    event.activity,
+    currentUser,
+    false
+  );
+  if (decision === "ignore") {
+    return;
   }
+  const position = decision === "add-to-end" ? "end" : "start";
   const currentActivities = this.currentState.activities;
   const result = addActivitiesToState.bind(this)(
     [event.activity],
     currentActivities,
-    this.currentState.addNewActivitiesTo,
-    { fromWebSocket: true }
+    position,
+    { hasOwnFields: false, backfillOwnFields: true }
   );
   if (result.changed) {
     const activity = event.activity;
@@ -5853,7 +5999,19 @@ const removePinnedActivityFromState = (activityResponse, pinnedActivities) => {
     return { changed: false, pinned_activities: pinnedActivities };
   }
 };
-function handleActivityDeleted(event) {
+function handleActivityDeleted(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "activity-deleted"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
+  }
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -5938,7 +6096,10 @@ function handleActivityUpdated(payload, fromWs) {
     updatePinnedActivityInState(payload, currentPinnedActivities)
   ];
   if (result1?.changed || result2.changed) {
-    this.client.hydratePollCache([payload.activity]);
+    this.activitiesAddedOrUpdated([payload.activity], {
+      hasOwnFields: payload.activity.current_feed?.own_capabilities !== void 0,
+      backfillOwnFields: false
+    });
     this.state.partialNext({
       activities: result1?.changed ? result1.entities : currentActivities,
       pinned_activities: result2.entities
@@ -6196,53 +6357,133 @@ function handleActivityReactionUpdated(payload, fromWs) {
     });
   }
 }
-const updateNotificationStatusFromActivityMarked = (event, currentNotificationStatus, aggregatedActivities = []) => {
-  if (!currentNotificationStatus) {
-    return {
-      changed: false
-    };
-  }
-  const newState = {
-    ...currentNotificationStatus
-  };
-  if (event.mark_all_read) {
-    const allGroupIds = aggregatedActivities.map((activity) => activity.group);
-    newState.read_activities = [
-      .../* @__PURE__ */ new Set([
-        ...currentNotificationStatus.read_activities ?? [],
-        ...allGroupIds
-      ])
-    ];
+function handleActivityPinned(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "activity-pinned"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
   }
-  if (event.mark_read && event.mark_read.length > 0) {
-    newState.read_activities = [
-      .../* @__PURE__ */ new Set([
-        ...currentNotificationStatus?.read_activities ?? [],
-        ...event.mark_read
-      ])
-    ];
+  this.state.next((currentState) => {
+    const newState = {
+      ...currentState
+    };
+    const pinnedActivity = {
+      ...event.pinned_activity,
+      user: event.user,
+      updated_at: /* @__PURE__ */ new Date()
+    };
+    newState.pinned_activities = currentState.pinned_activities ? [pinnedActivity, ...currentState.pinned_activities] : [pinnedActivity];
+    return newState;
+  });
+}
+function handleActivityUnpinned(event, fromWs) {
+  if (!shouldUpdateState({
+    stateUpdateQueueId: getStateUpdateQueueId(event, "activity-unpinned"),
+    stateUpdateQueue: this.stateUpdateQueue,
+    watch: this.currentState.watch,
+    fromWs,
+    isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+      this,
+      event
+    )
+  })) {
+    return;
   }
-  if (event.mark_all_seen) {
-    newState.last_seen_at = /* @__PURE__ */ new Date();
+  this.state.next((currentState) => {
+    let newState;
+    const index = currentState.pinned_activities?.findIndex(
+      (pinnedActivity) => pinnedActivity.activity.id === event.pinned_activity.activity.id
+    ) ?? -1;
+    if (index >= 0) {
+      newState ?? (newState = {
+        ...currentState
+      });
+      const newPinnedActivities = [...currentState.pinned_activities];
+      newPinnedActivities.splice(index, 1);
+      newState.pinned_activities = newPinnedActivities;
+    }
+    return newState ?? currentState;
+  });
+}
+const isPin = (entity) => {
+  return "activity" in entity;
+};
+const updateActivityFromFeedback = (feedback, activities) => {
+  if (!activities) {
+    return {
+      changed: false,
+      entities: []
+    };
   }
-  return {
-    changed: true,
-    data: { notification_status: newState }
-  };
+  return updateEntityInArray({
+    entities: activities,
+    matcher: (e) => {
+      const newHidden = feedback.value === "true";
+      if (isPin(e)) {
+        return e.activity.id === feedback.activity_id && e.activity.hidden !== newHidden;
+      }
+      return e.id === feedback.activity_id && e.hidden !== newHidden;
+    },
+    updater: (e) => {
+      if (isPin(e)) {
+        return {
+          ...e,
+          activity: {
+            ...e.activity,
+            hidden: feedback.value === "true"
+          }
+        };
+      } else {
+        return {
+          ...e,
+          hidden: feedback.value === "true"
+        };
+      }
+    }
+  });
 };
-function handleActivityMarked(event) {
-  const result = updateNotificationStatusFromActivityMarked(
-    event,
-    this.currentState.notification_status,
-    this.currentState.aggregated_activities
-  );
-  if (result.changed) {
+function handleActivityFeedback(event) {
+  const {
+    activities: currentActivities,
+    pinned_activities: currentPinnedActivities
+  } = this.currentState;
+  const { connected_user: connectedUser } = this.client.state.getLatestValue();
+  const eventBelongsToCurrentUser = event.activity_feedback.user.id === connectedUser?.id;
+  if (!eventBelongsToCurrentUser || event.activity_feedback.action !== "hide") {
+    return;
+  }
+  const [result1, result2] = [
+    updateActivityFromFeedback(event.activity_feedback, currentActivities),
+    updateActivityFromFeedback(
+      event.activity_feedback,
+      currentPinnedActivities
+    )
+  ];
+  if (result1.changed || result2.changed) {
     this.state.partialNext({
-      notification_status: result.data?.notification_status
+      activities: result1.entities,
+      pinned_activities: result2.entities
     });
   }
 }
+function handleFeedDeleted(event) {
+  if (this.currentState.deleted_at) {
+    return;
+  }
+  this.state.partialNext({ deleted_at: event.created_at });
+}
 function handleFeedUpdated(event) {
+  const currentUpdatedAt = this.currentState.updated_at;
+  if (currentUpdatedAt && event.feed.updated_at && currentUpdatedAt.getTime() >= event.feed.updated_at.getTime()) {
+    return;
+  }
   this.state.partialNext({ ...event.feed });
 }
 const addAggregatedActivitiesToState = (newAggregatedActivities, aggregatedActivities, position) => {
@@ -6291,11 +6532,20 @@ const addAggregatedActivitiesToState = (newAggregatedActivities, aggregatedActiv
           (a) => a.group
         );
         break;
-      case "replace":
+      case "replace-then-end":
         result.aggregated_activities = replaceUniqueArrayMerge(
           aggregatedActivities ?? [],
           newAggregatedActivities,
-          (a) => a.group
+          (a) => a.group,
+          "end"
+        );
+        break;
+      case "replace-then-start":
+        result.aggregated_activities = replaceUniqueArrayMerge(
+          aggregatedActivities ?? [],
+          newAggregatedActivities,
+          (a) => a.group,
+          "start"
         );
         break;
     }
@@ -6322,7 +6572,7 @@ const updateNotificationStatus = (newNotificationStatus, currentNotificationStat
     };
   }
 };
-const updateNotificationFeedFromEvent = (event, currentAggregatedActivities, currentNotificationStatus) => {
+const updateNotificationFeedFromEvent = (event, currentAggregatedActivities, currentNotificationStatus, currentActivities) => {
   const updates = {};
   if (event.notification_status) {
     const notificationStatusResult = updateNotificationStatus(
@@ -6333,11 +6583,47 @@ const updateNotificationFeedFromEvent = (event, currentAggregatedActivities, cur
       updates.notification_status = notificationStatusResult.notification_status;
     }
   }
+  const effectiveStatus = event.notification_status ?? currentNotificationStatus;
+  const lastReadAt = effectiveStatus?.last_read_at;
+  const lastSeenAt = effectiveStatus?.last_seen_at;
+  const readActivities = effectiveStatus?.read_activities ?? [];
+  const seenActivities = effectiveStatus?.seen_activities ?? [];
+  if (currentActivities?.length && !currentAggregatedActivities?.length && effectiveStatus) {
+    let anyChanged = false;
+    const updatedActivities = currentActivities.map((activity) => {
+      const isRead = lastReadAt != null && activity.updated_at.getTime() < lastReadAt.getTime() || readActivities.includes(activity.id);
+      const isSeen = lastSeenAt != null && activity.updated_at.getTime() < lastSeenAt.getTime() || seenActivities.includes(activity.id);
+      if (activity.is_read !== isRead || activity.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...activity, is_read: isRead, is_seen: isSeen };
+      }
+      return activity;
+    });
+    if (anyChanged) {
+      updates.activities = updatedActivities;
+    }
+  }
+  if (currentAggregatedActivities?.length && effectiveStatus) {
+    const baseAggregated = currentAggregatedActivities;
+    let anyChanged = false;
+    const updatedAggregated = baseAggregated.map((group) => {
+      const isRead = lastReadAt != null && group.updated_at.getTime() < lastReadAt.getTime() || readActivities.includes(group.group);
+      const isSeen = lastSeenAt != null && group.updated_at.getTime() < lastSeenAt.getTime() || seenActivities.includes(group.group);
+      if (group.is_read !== isRead || group.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...group, is_read: isRead, is_seen: isSeen };
+      }
+      return group;
+    });
+    if (anyChanged) {
+      updates.aggregated_activities = updatedAggregated;
+    }
+  }
   if (event.aggregated_activities && currentAggregatedActivities) {
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
-      currentAggregatedActivities,
-      "start"
+      updates.aggregated_activities ?? currentAggregatedActivities,
+      "replace-then-start"
     );
     if (aggregatedActivitiesResult.changed) {
       updates.aggregated_activities = aggregatedActivitiesResult.aggregated_activities;
@@ -6357,12 +6643,14 @@ function handleNotificationFeedUpdated(event) {
   const result = updateNotificationFeedFromEvent(
     event,
     this.currentState.aggregated_activities,
-    this.currentState.notification_status
+    this.currentState.notification_status,
+    this.currentState.activities
   );
   if (result.changed) {
     this.state.partialNext({
       notification_status: result.data?.notification_status,
-      aggregated_activities: result.data?.aggregated_activities
+      aggregated_activities: result.data?.aggregated_activities,
+      activities: result.data?.activities ?? this.currentState.activities
     });
   }
 }
@@ -6412,7 +6700,7 @@ function updateStoriesFeedFromEvent(aggregatedActivities, activities, event) {
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
       aggregatedActivities,
-      "replace"
+      "replace-then-end"
     );
     if (aggregatedActivitiesResult.changed) {
       result.data.aggregated_activities = aggregatedActivitiesResult.aggregated_activities;
@@ -6450,6 +6738,30 @@ function handleWatchStarted() {
 function handleWatchStopped() {
   this.state.partialNext({ watch: false });
 }
+const activityResolvers = [
+  {
+    matchesField: (field) => field === "activity_type",
+    resolve: (activity) => activity.type
+  },
+  {
+    matchesField: (field) => field === "within_bounds",
+    resolve: (activity) => activity.location
+  },
+  {
+    matchesField: () => true,
+    resolve: (item, path) => filter.resolveDotPathValue(item, path)
+  }
+];
+function activityFilter(activity, requestConfig) {
+  const filter$1 = requestConfig?.filter;
+  if (!filter$1 || typeof filter$1 !== "object") {
+    return true;
+  }
+  return filter.itemMatchesFilter(activity, filter$1, {
+    resolvers: [...activityResolvers],
+    arrayEqMode: "contains"
+  });
+}
 const DEFAULT_MAX_RETRIES = 3;
 function isRetryableError(error) {
   if (error instanceof StreamApiError) {
@@ -6482,61 +6794,6 @@ async function withRetry(fn, options = {}) {
   }
   throw lastError;
 }
-const isPin = (entity) => {
-  return "activity" in entity;
-};
-const updateActivityFromFeedback = (feedback, activities) => {
-  if (!activities) {
-    return {
-      changed: false,
-      entities: []
-    };
-  }
-  return updateEntityInArray({
-    entities: activities,
-    matcher: (e) => isPin(e) ? e.activity.id === feedback.activity_id : e.id === feedback.activity_id,
-    updater: (e) => {
-      if (isPin(e)) {
-        return {
-          ...e,
-          activity: {
-            ...e.activity,
-            hidden: feedback.value === "true"
-          }
-        };
-      } else {
-        return {
-          ...e,
-          hidden: feedback.value === "true"
-        };
-      }
-    }
-  });
-};
-function handleActivityFeedback(event) {
-  const {
-    activities: currentActivities,
-    pinned_activities: currentPinnedActivities
-  } = this.currentState;
-  const { connected_user: connectedUser } = this.client.state.getLatestValue();
-  const eventBelongsToCurrentUser = event.activity_feedback.user.id === connectedUser?.id;
-  if (!eventBelongsToCurrentUser || event.activity_feedback.action !== "hide") {
-    return;
-  }
-  const [result1, result2] = [
-    updateActivityFromFeedback(event.activity_feedback, currentActivities),
-    updateActivityFromFeedback(
-      event.activity_feedback,
-      currentPinnedActivities
-    )
-  ];
-  if (result1.changed || result2.changed) {
-    this.state.partialNext({
-      activities: result1.entities,
-      pinned_activities: result2.entities
-    });
-  }
-}
 const deepEqual = (x, y) => {
   if (x === y) {
     return true;
@@ -6641,9 +6898,9 @@ function clearQueuedFeeds() {
   queuedFeeds.clear();
 }
 const _Feed = class _Feed extends FeedApi {
-  constructor(client, groupId, id, data, watch = false, addNewActivitiesTo = "start", activityAddedEventFilter) {
+  constructor(client, groupId, id, data, watch = false, onNewActivity) {
     super(client, groupId, id);
-    this.activityAddedEventFilter = activityAddedEventFilter;
+    this.onNewActivity = onNewActivity;
     this.indexedActivityIds = /* @__PURE__ */ new Set();
     this.stateUpdateQueue = /* @__PURE__ */ new Set();
     this.eventHandlers = {
@@ -6663,7 +6920,7 @@ const _Feed = class _Feed extends FeedApi {
       "feeds.comment.deleted": handleCommentDeleted.bind(this),
       "feeds.comment.updated": handleCommentUpdated.bind(this),
       "feeds.feed.created": _Feed.noop,
-      "feeds.feed.deleted": _Feed.noop,
+      "feeds.feed.deleted": handleFeedDeleted.bind(this),
       "feeds.feed.updated": handleFeedUpdated.bind(this),
       "feeds.feed_group.changed": _Feed.noop,
       "feeds.feed_group.deleted": _Feed.noop,
@@ -6686,9 +6943,9 @@ const _Feed = class _Feed extends FeedApi {
       "feeds.poll.vote_casted": _Feed.noop,
       "feeds.poll.vote_changed": _Feed.noop,
       "feeds.poll.vote_removed": _Feed.noop,
-      "feeds.activity.pinned": _Feed.noop,
-      "feeds.activity.unpinned": _Feed.noop,
-      "feeds.activity.marked": handleActivityMarked.bind(this),
+      "feeds.activity.pinned": handleActivityPinned.bind(this),
+      "feeds.activity.unpinned": handleActivityUnpinned.bind(this),
+      "feeds.activity.marked": _Feed.noop,
       "moderation.custom_action": _Feed.noop,
       "moderation.flagged": _Feed.noop,
       "moderation.mark_reviewed": _Feed.noop,
@@ -6713,8 +6970,7 @@ const _Feed = class _Feed extends FeedApi {
       is_loading: false,
       is_loading_activities: false,
       comments_by_entity_id: {},
-      watch,
-      addNewActivitiesTo
+      watch
     });
     this.client = client;
     this.state.subscribeWithSelector(
@@ -6735,9 +6991,6 @@ const _Feed = class _Feed extends FeedApi {
   get currentState() {
     return this.state.getLatestValue();
   }
-  set addNewActivitiesTo(value) {
-    this.state.partialNext({ addNewActivitiesTo: value });
-  }
   hasActivity(activityId) {
     return this.indexedActivityIds.has(activityId);
   }
@@ -6746,6 +6999,24 @@ const _Feed = class _Feed extends FeedApi {
       (pinnedActivity) => pinnedActivity.activity.id === activityId
     );
   }
+  /**
+   * Resolves how to handle a new activity (WS or HTTP): ignore, add-to-start, or add-to-end.
+   * Uses onNewActivity if set; else default (current user + filter match) adds to start.
+   */
+  resolveNewActivityDecision(activity, currentUser, _fromHttp) {
+    if (this.onNewActivity) {
+      return this.onNewActivity({ activity, currentUser });
+    }
+    if (!currentUser) return "ignore";
+    if (activity.user?.id !== currentUser.id) return "ignore";
+    if (!activityFilter(
+      activity,
+      this.currentState.last_get_or_create_request_config
+    )) {
+      return "ignore";
+    }
+    return "add-to-start";
+  }
   async synchronize() {
     const { last_get_or_create_request_config } = this.state.getLatestValue();
     if (last_get_or_create_request_config?.watch) {
@@ -6783,7 +7054,8 @@ const _Feed = class _Feed extends FeedApi {
         const result = addActivitiesToState.bind(this)(
           response.activities,
           currentActivities,
-          "end"
+          "end",
+          { hasOwnFields: true, backfillOwnFields: false }
         );
         const aggregatedActivitiesResult = addAggregatedActivitiesToState(
           response.aggregated_activities,
@@ -6832,7 +7104,7 @@ const _Feed = class _Feed extends FeedApi {
           return nextState;
         });
       }
-      this.newActivitiesAdded(response.activities);
+      this.activitiesAddedOrUpdated(response.activities);
       return response;
     } finally {
       this.state.partialNext({
@@ -7140,11 +7412,11 @@ const _Feed = class _Feed extends FeedApi {
    * _Note: Useful only for feeds with `groupId` of `user` value._
    */
   async queryFollowers(request) {
-    const filter = {
+    const filter2 = {
       target_feed: this.feed
     };
     const response = await this.client.queryFollows({
-      filter,
+      filter: filter2,
       ...request
     });
     return response;
@@ -7155,11 +7427,11 @@ const _Feed = class _Feed extends FeedApi {
    * _Note: Useful only for feeds with `groupId` of `timeline` value._
    */
   async queryFollowing(request) {
-    const filter = {
+    const filter2 = {
       source_feed: this.feed
     };
     const response = await this.client.queryFollows({
-      filter,
+      filter: filter2,
       ...request
     });
     return response;
@@ -7207,11 +7479,41 @@ const _Feed = class _Feed extends FeedApi {
       next: currentState.next
     });
   }
+  /**
+   * Applies a new activity to this feed's state (decision + add to activities).
+   * Used when the activity was added via this feed's addActivity or via client.addActivity.
+   */
+  addActivityFromHTTPResponse(activity) {
+    const currentUser = this.client.state.getLatestValue().connected_user;
+    const decision = this.resolveNewActivityDecision(
+      activity,
+      currentUser,
+      true
+    );
+    if (decision !== "ignore") {
+      const position = decision === "add-to-end" ? "end" : "start";
+      const currentActivities = this.currentState.activities;
+      const result = addActivitiesToState.bind(this)(
+        [activity],
+        currentActivities,
+        position,
+        {
+          hasOwnFields: activity.current_feed?.own_capabilities !== void 0,
+          backfillOwnFields: false
+        }
+      );
+      if (result.changed) {
+        this.client.hydratePollCache([activity]);
+        this.state.partialNext({ activities: result.activities });
+      }
+    }
+  }
   async addActivity(request) {
     const response = await this.client.addActivity({
       ...request,
       feeds: [this.feed]
     });
+    this.addActivityFromHTTPResponse(response.activity);
     return response;
   }
   handleWSEvent(event) {
@@ -7232,7 +7534,7 @@ const _Feed = class _Feed extends FeedApi {
     }
     this.eventDispatcher.dispatch(event);
   }
-  newActivitiesAdded(activities, options = { fromWebSocket: false }) {
+  activitiesAddedOrUpdated(activities, options = { hasOwnFields: true, backfillOwnFields: true }) {
     this.client.hydratePollCache(activities);
     this.getOrCreateFeeds(activities, options);
   }
@@ -7250,7 +7552,7 @@ const _Feed = class _Feed extends FeedApi {
       });
       const newFeeds = Array.from(feedsToGetOrCreate.values());
       const fieldsToUpdate = [];
-      if (!options.fromWebSocket) {
+      if (options.hasOwnFields) {
         fieldsToUpdate.push("own_membership");
         if (!enrichmentOptions?.skip_own_capabilities) {
           fieldsToUpdate.push("own_capabilities");
@@ -7270,7 +7572,7 @@ const _Feed = class _Feed extends FeedApi {
           fieldsToUpdate
         });
       });
-      if (options.fromWebSocket) {
+      if (!options.hasOwnFields && options.backfillOwnFields) {
         const uninitializedFeeds = newFeeds.filter((feedResponse) => {
           const feed = this.client.feed(feedResponse.group_id, feedResponse.id);
           return feed.currentState.own_capabilities === void 0;
@@ -7293,6 +7595,9 @@ const _Feed = class _Feed extends FeedApi {
 _Feed.noop = () => {
 };
 let Feed = _Feed;
+function applyNewActivityToActiveFeeds(activity) {
+  return this.addActivityFromHTTPResponse(activity);
+}
 function handleUserUpdated(event) {
   this.state.next((currentState) => {
     let newState;
@@ -7372,7 +7677,9 @@ function disconnectActivityFromFeed(activity) {
   }
 }
 class ActivityWithStateUpdates {
-  constructor(id, feedsClient, { fromResponse } = { fromResponse: void 0 }) {
+  constructor(id, feedsClient, { fromResponse } = {
+    fromResponse: void 0
+  }) {
     this.id = id;
     this.feedsClient = feedsClient;
     this.state = new stateStore.StateStore({
@@ -7423,7 +7730,7 @@ class ActivityWithStateUpdates {
       initialState: activityResponse
     });
     if (this.feed) {
-      this.feed.activityAddedEventFilter = () => false;
+      this.feed.onNewActivity = () => "ignore";
     }
     if (comments) {
       await this.loadNextPageActivityComments(comments);
@@ -7476,7 +7783,11 @@ class ActivityWithStateUpdates {
     const { activities } = addActivitiesToState.bind(this.feed)(
       [initialState],
       [],
-      "start"
+      "start",
+      {
+        hasOwnFields: initialState.current_feed?.own_capabilities !== void 0,
+        backfillOwnFields: false
+      }
     );
     this.feed?.state.partialNext({
       activities
@@ -7748,6 +8059,53 @@ class FeedsClient extends FeedsApi {
       }
       return response;
     };
+    this.updateActivityPartial = async (...args) => {
+      const response = await super.updateActivityPartial(...args);
+      for (const feed of this.allActiveFeeds) {
+        handleActivityUpdated.bind(feed)(response, false);
+      }
+      return response;
+    };
+    this.deleteActivity = async (...args) => {
+      const response = await super.deleteActivity(...args);
+      const activityId = args[0].id;
+      for (const feed of this.allActiveFeeds) {
+        handleActivityDeleted.bind(feed)(
+          { activity: { id: activityId } },
+          false
+        );
+      }
+      this.activeActivities = this.activeActivities.filter(
+        (activity) => activity.id !== activityId
+      );
+      return response;
+    };
+    this.activityFeedback = async (request) => {
+      const response = await super.activityFeedback(request);
+      if (request.hide !== void 0) {
+        const feedback = {
+          activity_id: request.activity_id,
+          value: request.hide ? "true" : "false"
+        };
+        for (const feed of this.allActiveFeeds) {
+          const {
+            activities: currentActivities,
+            pinned_activities: currentPinnedActivities
+          } = feed.currentState;
+          const [result1, result2] = [
+            updateActivityFromFeedback(feedback, currentActivities),
+            updateActivityFromFeedback(feedback, currentPinnedActivities)
+          ];
+          if (result1.changed || result2.changed) {
+            feed.state.partialNext({
+              activities: result1.entities,
+              pinned_activities: result2.entities
+            });
+          }
+        }
+      }
+      return response;
+    };
     this.addComment = async (request) => {
       const response = await super.addComment(request);
       const { comment } = response;
@@ -7833,10 +8191,125 @@ class FeedsClient extends FeedsApi {
       }
       return response;
     };
+    this.addBookmark = async (request) => {
+      const response = await super.addBookmark(request);
+      for (const feed of this.allActiveFeeds) {
+        handleBookmarkAdded.bind(feed)(response);
+      }
+      return response;
+    };
+    this.updateBookmark = async (request) => {
+      const response = await super.updateBookmark(request);
+      for (const feed of this.allActiveFeeds) {
+        handleBookmarkUpdated.bind(feed)(response);
+      }
+      return response;
+    };
+    this.deleteBookmark = async (request) => {
+      const response = await super.deleteBookmark(request);
+      for (const feed of this.allActiveFeeds) {
+        handleBookmarkDeleted.bind(feed)(response);
+      }
+      return response;
+    };
+    this.pinActivity = async (...args) => {
+      const response = await super.pinActivity(...args);
+      const feedIds = response.activity?.feeds ?? (response.feed ? [response.feed] : []);
+      for (const fid of feedIds) {
+        const feed = this.activeFeeds[fid];
+        if (feed) {
+          handleActivityPinned.bind(feed)(
+            { pinned_activity: response },
+            false
+          );
+        }
+      }
+      return response;
+    };
+    this.unpinActivity = async (...args) => {
+      const response = await super.unpinActivity(...args);
+      const feedIds = response.activity?.feeds ?? (response.feed ? [response.feed] : []);
+      for (const fid of feedIds) {
+        const feed = this.activeFeeds[fid];
+        if (feed) {
+          handleActivityUnpinned.bind(feed)(
+            {
+              pinned_activity: {
+                ...response,
+                created_at: /* @__PURE__ */ new Date()
+              }
+            },
+            false
+          );
+        }
+      }
+      return response;
+    };
+    this.updateFeed = async (...args) => {
+      const response = await super.updateFeed(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedUpdated.call(feed, { feed: response.feed });
+      }
+      return response;
+    };
+    this.deleteFeed = async (...args) => {
+      const response = await super.deleteFeed(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedDeleted.call(feed, {
+          created_at: /* @__PURE__ */ new Date()
+        });
+        if (!feed.currentState.watch) {
+          delete this.activeFeeds[fid];
+          this.activeActivities = this.activeActivities.filter(
+            (activity) => getFeed.call(activity)?.feed !== fid
+          );
+        }
+      }
+      return response;
+    };
+    this.updateFeedMembers = async (...args) => {
+      const response = await super.updateFeedMembers(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        for (const member of response.added) {
+          handleFeedMemberAdded.call(feed, { member }, false);
+        }
+        for (const member of response.updated) {
+          handleFeedMemberUpdated.call(feed, { member }, false);
+        }
+        for (const memberId of response.removed_ids) {
+          handleFeedMemberRemoved.call(feed, { member_id: memberId }, false);
+        }
+      }
+      return response;
+    };
+    this.acceptFeedMemberInvite = async (...args) => {
+      const response = await super.acceptFeedMemberInvite(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedMemberUpdated.call(feed, { member: response.member }, false);
+      }
+      return response;
+    };
+    this.rejectFeedMemberInvite = async (...args) => {
+      const response = await super.rejectFeedMemberInvite(...args);
+      const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleFeedMemberUpdated.call(feed, { member: response.member }, false);
+      }
+      return response;
+    };
     this.queryPollAnswers = async (request) => {
-      const filter = request.filter ?? {};
+      const filter2 = request.filter ?? {};
       const queryPollAnswersFilter = {
-        ...filter,
+        ...filter2,
         is_answer: true
       };
       const queryPollAnswersRequest = {
@@ -7907,18 +8380,12 @@ class FeedsClient extends FeedsApi {
           id,
           data,
           watch,
-          options2?.addNewActivitiesTo,
-          options2?.activityAddedEventFilter
+          options2?.onNewActivity
         );
       }
       const feed = this.activeFeeds[fid];
-      if (!isCreated && options2) {
-        if (options2?.addNewActivitiesTo) {
-          feed.addNewActivitiesTo = options2.addNewActivitiesTo;
-        }
-        if (options2?.activityAddedEventFilter) {
-          feed.activityAddedEventFilter = options2.activityAddedEventFilter;
-        }
+      if (!isCreated && options2?.onNewActivity !== void 0) {
+        feed.onNewActivity = options2.onNewActivity;
       }
       if (!feed.currentState.watch) {
         if (!isCreated && data) {
@@ -8098,6 +8565,16 @@ class FeedsClient extends FeedsApi {
       });
     }
   }
+  async addActivity(request) {
+    const response = await super.addActivity(request);
+    request.feeds.forEach((fid) => {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        applyNewActivityToActiveFeeds.call(feed, response.activity);
+      }
+    });
+    return response;
+  }
   async queryFeeds(request) {
     const response = await this._queryFeeds(request);
     const feedResponses = response.feeds;
@@ -8107,12 +8584,12 @@ class FeedsClient extends FeedsApi {
         id: feedResponse.id,
         data: feedResponse,
         watch: request?.watch,
-        fieldsToUpdate: [
+        fieldsToUpdate: request?.enrich_own_fields ? [
           "own_capabilities",
           "own_follows",
           "own_membership",
           "own_followings"
-        ]
+        ] : []
       })
     );
     return {
@@ -8144,10 +8621,21 @@ class FeedsClient extends FeedsApi {
     });
     return response;
   }
+  async acceptFollow(...args) {
+    const response = await super.acceptFollow(...args);
+    [
+      response.follow.source_feed.feed,
+      response.follow.target_feed.feed
+    ].forEach((fid) => {
+      const feeds = this.findAllActiveFeedsByFid(fid);
+      feeds.forEach((f) => handleFollowUpdated.bind(f)(response, false));
+    });
+    return response;
+  }
   // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
   async follow(request) {
     const response = await super.follow(request);
-    this.updateStateFromFollows([response.follow]);
+    this.updateStateFromFollows([response.follow], !!request.enrich_own_fields);
     return response;
   }
   /**
@@ -8157,12 +8645,12 @@ class FeedsClient extends FeedsApi {
    */
   async followBatch(request) {
     const response = await super.followBatch(request);
-    this.updateStateFromFollows(response.follows);
+    this.updateStateFromFollows(response.follows, !!request.enrich_own_fields);
     return response;
   }
   async getOrCreateFollows(request) {
     const response = await super.getOrCreateFollows(request);
-    this.updateStateFromFollows(response.created);
+    this.updateStateFromFollows(response.created, !!request.enrich_own_fields);
     return response;
   }
   async unfollow(request) {
@@ -8253,13 +8741,15 @@ class FeedsClient extends FeedsApi {
       }).map((a) => getFeed.call(a))
     ];
   }
-  updateStateFromFollows(follows) {
+  updateStateFromFollows(follows, hasOwnFields) {
     follows.forEach((follow) => {
       const feeds = [
         ...this.findAllActiveFeedsByFid(follow.source_feed.feed),
         ...this.findAllActiveFeedsByFid(follow.target_feed.feed)
       ];
-      feeds.forEach((f) => handleFollowCreated.bind(f)({ follow }, false));
+      feeds.forEach(
+        (f) => handleFollowCreated.bind(f)({ follow }, false, hasOwnFields)
+      );
     });
   }
   updateStateFromUnfollows(follows) {
@@ -8290,6 +8780,7 @@ exports.Feed = Feed;
 exports.FeedsClient = FeedsClient;
 exports.StreamApiError = StreamApiError;
 exports.StreamPoll = StreamPoll;
+exports.activityFilter = activityFilter;
 exports.checkHasAnotherPage = checkHasAnotherPage;
 exports.debounce = debounce;
 exports.ensureExhausted = ensureExhausted;
@@ -8305,4 +8796,4 @@ exports.replaceUniqueArrayMerge = replaceUniqueArrayMerge;
 exports.shouldUpdateState = shouldUpdateState;
 exports.uniqueArrayMerge = uniqueArrayMerge;
 exports.updateEntityInArray = updateEntityInArray;
-//# sourceMappingURL=feeds-client-B4zeBggL.js.map
+//# sourceMappingURL=feeds-client-C1c6lcS3.js.map