@stream-io/feeds-client 0.3.51 → 1.1.0

package/dist/{feeds-client-DeAqnd1a.mjs → feeds-client-jtUTE4AC.mjs}

@@ -1,6 +1,7 @@
 import { StateStore } from "@stream-io/state-store";
 import * as loggerInternal from "@stream-io/logger";
 import axiosImport from "axios";
+import { itemMatchesFilter, resolveDotPathValue } from "@stream-io/filter";
 const decoders = {};
 const decodeDatetimeType = (input) => typeof input === "number" ? new Date(Math.floor(input / 1e6)) : new Date(input);
 decoders.DatetimeType = decodeDatetimeType;
@@ -1122,6 +1123,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 }
@@ -1696,6 +1703,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,
@@ -2108,6 +2130,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,
@@ -2167,6 +2208,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,
@@ -3198,15 +3240,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
     };
@@ -3216,13 +3269,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) {
@@ -4110,7 +4163,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) {
@@ -4926,7 +4979,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);
@@ -4942,9 +4995,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 = {
@@ -4991,24 +5049,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":
@@ -5020,6 +5079,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.");
     }
@@ -5045,7 +5111,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 };
   }
@@ -5054,7 +5120,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];
@@ -5067,9 +5138,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) {
@@ -5078,7 +5154,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"),
@@ -5094,7 +5170,8 @@ function handleFollowCreated(eventOrResponse, fromWs) {
     follow,
     this.currentState,
     this.feed,
-    connectedUser?.id
+    connectedUser?.id,
+    hasOwnFields
   );
   if (result.changed) {
     this.state.next(result.data);
@@ -5177,7 +5254,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
@@ -5194,7 +5276,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(
@@ -5318,14 +5405,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;
   }
@@ -5335,7 +5422,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: {
@@ -5486,7 +5576,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;
@@ -5505,7 +5607,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(
@@ -5529,7 +5643,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;
@@ -5549,6 +5675,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,
@@ -5556,7 +5685,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,
@@ -5564,18 +5695,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,
@@ -5591,7 +5724,7 @@ const addBookmarkToPinnedActivities = (event, pinnedActivities, eventBelongsToCu
     };
   }
 });
-function handleBookmarkAdded(event) {
+function handleBookmarkDeleted(event) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -5599,12 +5732,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
@@ -5617,9 +5750,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,
@@ -5627,9 +5757,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,
@@ -5637,18 +5765,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,
@@ -5664,7 +5794,7 @@ const removeBookmarkFromPinnedActivities = (event, pinnedActivities, eventBelong
     };
   }
 });
-function handleBookmarkDeleted(event) {
+function handleBookmarkAdded(event) {
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities
@@ -5672,12 +5802,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
@@ -5698,7 +5828,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];
@@ -5713,7 +5843,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,
@@ -5722,7 +5852,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,
@@ -5764,7 +5896,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,
@@ -5787,23 +5925,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;
@@ -5835,7 +5981,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
@@ -5920,7 +6078,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
@@ -6178,53 +6339,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) => {
@@ -6273,11 +6514,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;
     }
@@ -6304,7 +6554,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(
@@ -6315,11 +6565,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;
@@ -6339,12 +6625,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
     });
   }
 }
@@ -6394,7 +6682,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;
@@ -6432,6 +6720,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) => resolveDotPathValue(item, path)
+  }
+];
+function activityFilter(activity, requestConfig) {
+  const filter = requestConfig?.filter;
+  if (!filter || typeof filter !== "object") {
+    return true;
+  }
+  return itemMatchesFilter(activity, filter, {
+    resolvers: [...activityResolvers],
+    arrayEqMode: "contains"
+  });
+}
 const DEFAULT_MAX_RETRIES = 3;
 function isRetryableError(error) {
   if (error instanceof StreamApiError) {
@@ -6464,61 +6776,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;
@@ -6623,9 +6880,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 = {
@@ -6645,7 +6902,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,
@@ -6668,9 +6925,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,
@@ -6695,8 +6952,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(
@@ -6717,9 +6973,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);
   }
@@ -6728,6 +6981,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) {
@@ -6765,7 +7036,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,
@@ -6814,7 +7086,7 @@ const _Feed = class _Feed extends FeedApi {
           return nextState;
         });
       }
-      this.newActivitiesAdded(response.activities);
+      this.activitiesAddedOrUpdated(response.activities);
       return response;
     } finally {
       this.state.partialNext({
@@ -7189,11 +7461,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) {
@@ -7214,7 +7516,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);
   }
@@ -7232,7 +7534,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");
@@ -7252,7 +7554,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;
@@ -7275,6 +7577,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;
@@ -7354,7 +7659,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({
@@ -7405,7 +7712,7 @@ class ActivityWithStateUpdates {
       initialState: activityResponse
     });
     if (this.feed) {
-      this.feed.activityAddedEventFilter = () => false;
+      this.feed.onNewActivity = () => "ignore";
     }
     if (comments) {
       await this.loadNextPageActivityComments(comments);
@@ -7458,7 +7765,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
@@ -7730,6 +8041,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;
@@ -7815,6 +8173,121 @@ 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 queryPollAnswersFilter = {
@@ -7889,18 +8362,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) {
@@ -8080,6 +8547,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;
@@ -8089,12 +8566,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 {
@@ -8126,10 +8603,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;
   }
   /**
@@ -8139,12 +8627,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) {
@@ -8235,13 +8723,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) {
@@ -8271,22 +8761,23 @@ export {
   Constants as C,
   FeedsClient as F,
   StreamApiError as S,
-  Feed as a,
-  StreamPoll as b,
-  checkHasAnotherPage as c,
+  activityFilter as a,
+  Feed as b,
+  StreamPoll as c,
   debounce as d,
-  isFollowResponse as e,
-  isReactionResponse as f,
-  isCommentResponse as g,
-  isImageFile as h,
+  checkHasAnotherPage as e,
+  isFollowResponse as f,
+  isReactionResponse as g,
+  isCommentResponse as h,
   isVoteAnswer as i,
-  isVideoFile as j,
-  getStateUpdateQueueId as k,
-  updateEntityInArray as l,
-  feedsLoggerSystem as m,
-  ensureExhausted as n,
+  isImageFile as j,
+  isVideoFile as k,
+  getStateUpdateQueueId as l,
+  updateEntityInArray as m,
+  feedsLoggerSystem as n,
+  ensureExhausted as o,
   replaceUniqueArrayMerge as r,
   shouldUpdateState as s,
   uniqueArrayMerge as u
 };
-//# sourceMappingURL=feeds-client-DeAqnd1a.mjs.map
+//# sourceMappingURL=feeds-client-jtUTE4AC.mjs.map