@amityco/ts-sdk 7.22.1-fa4a2e0.0 → 7.23.0

package/dist/index.cjs.js

@@ -313,8 +313,8 @@ exports.NotificationRolesFilterTypeEnum = void 0;
 
 function getVersion() {
     try {
-        // the string ''v7.22.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.22.0-cjs';
+        // the string ''v7.23.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.23.0-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -1971,13 +1971,13 @@ class NetworkActivitiesWatcher {
         this._listener.clear();
     }
 }
-let instance$a;
+let instance$b;
 var NetworkActivitiesWatcher$1 = {
     getInstance: () => {
-        if (!instance$a) {
-            instance$a = new NetworkActivitiesWatcher();
+        if (!instance$b) {
+            instance$b = new NetworkActivitiesWatcher();
         }
-        return instance$a;
+        return instance$b;
     },
 };
 
@@ -4746,13 +4746,13 @@ class SessionWatcher {
         this._listener.clear();
     }
 }
-let instance$9;
+let instance$a;
 var SessionWatcher$1 = {
     getInstance: () => {
-        if (!instance$9) {
-            instance$9 = new SessionWatcher();
+        if (!instance$a) {
+            instance$a = new SessionWatcher();
         }
-        return instance$9;
+        return instance$a;
     },
 };
 
@@ -4849,11 +4849,11 @@ class AutoSubscriptionManager {
         this.seed();
     }
 }
-let instance$8 = null;
+let instance$9 = null;
 const getAutoSubscriptionManager = () => {
-    if (!instance$8)
-        instance$8 = new AutoSubscriptionManager();
-    return instance$8;
+    if (!instance$9)
+        instance$9 = new AutoSubscriptionManager();
+    return instance$9;
 };
 /** Resets the registry to its default baseline when the session ends. */
 const resetAutoSubscriptionsOnLogout = () => onSessionStateChange(state => {
@@ -6061,7 +6061,7 @@ getSubChannel$1.locally = (subChannelId) => {
     };
 };
 
-const getMessagePreviewSetting$1 = async () => {
+const getMessagePreviewSetting$2 = async () => {
     const client = getActiveClient();
     return client.getMessagePreviewSetting(false);
 };
@@ -6096,7 +6096,7 @@ const isLastestMessageOnChannel = (message) => {
         convertDateStringToTimestamp(cache.createdAt) <= convertDateStringToTimestamp(message.createdAt));
 };
 const handleMessageCreatedOnSubChannel = async (message) => {
-    const messagePreviewSetting = await getMessagePreviewSetting$1();
+    const messagePreviewSetting = await getMessagePreviewSetting$2();
     const { channelId, messageId: messagePreviewId, creatorId, createdAt, updatedAt, data, dataType, subChannelId, channelSegment: segment, isDeleted, } = message;
     // 1. get subChannel from cache, if not exist fetch from server
     const subChannelCache = await getSubChannelCache(subChannelId);
@@ -7447,7 +7447,7 @@ const convertMessagePreviewSetting = (chatSetting) => {
  * @category private
  * @async
  */
-const getMessagePreviewSetting = async (refresh = true) => {
+const getMessagePreviewSetting$1 = async (refresh = true) => {
     var _a;
     const messagePreviewSetting = (_a = pullFromCache([
         'MessagePreviewSetting',
@@ -7468,7 +7468,7 @@ const getMessagePreviewSetting = async (refresh = true) => {
  */
 const initializeMessagePreviewSetting = async () => {
     var _a;
-    const newMessagePreviewSetting = await getMessagePreviewSetting();
+    const newMessagePreviewSetting = await getMessagePreviewSetting$1();
     const messagePreviewSetting = (_a = pullFromCache([
         'MessagePreviewSetting',
     ])) === null || _a === void 0 ? void 0 : _a.data;
@@ -7582,6 +7582,33 @@ const getProductCatalogueSetting = async () => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: client.getForYouFeedSetting
+*/
+/**
+ * ```js
+ * import { Client } from '@amityco/ts-sdk'
+ * const forYouFeedSetting = await Client.getForYouFeedSetting()
+ * ```
+ *
+ * Fetches the network-level {@link Amity.ForYouFeedSetting} — whether the For You
+ * feed feature is enabled for the current network. Use `forYouFeed.enabled` as a
+ * feature gate before querying {@link getForYouFeed}.
+ *
+ * @returns A Promise of {@link Amity.ForYouFeedSetting} object
+ *
+ * @category Client API
+ * @async
+ */
+const getForYouFeedSetting = async () => {
+    var _a, _b;
+    const client = getActiveClient();
+    const { data } = await client.http.get(`/api/v3/network-settings/for-you-feed`);
+    // Surface only `enabled`; ignore server-side ranking config (scoringConfig, etc.)
+    return { forYouFeed: { enabled: (_b = (_a = data.forYouFeed) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false } };
+};
+/* end_public_function */
+
 const checkUserPermission = (userId, permission) => {
     var _a;
     const user = (_a = pullFromCache(['user', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data;
@@ -8369,13 +8396,13 @@ class AnalyticsEngine {
         this._eventCapturer.resetAllBuckets();
     }
 }
-let instance$7;
+let instance$8;
 var AnalyticsEngine$1 = {
     getInstance: () => {
-        if (!instance$7) {
-            instance$7 = new AnalyticsEngine();
+        if (!instance$8) {
+            instance$8 = new AnalyticsEngine();
         }
-        return instance$7;
+        return instance$8;
     },
 };
 
@@ -8602,12 +8629,12 @@ class MessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$6 = null;
+let instance$7 = null;
 var ReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$6)
-            instance$6 = new MessageReadReceiptSyncEngine();
-        return instance$6;
+        if (!instance$7)
+            instance$7 = new MessageReadReceiptSyncEngine();
+        return instance$7;
     },
 };
 
@@ -8861,12 +8888,12 @@ class LegacyMessageReadReceiptSyncEngine {
         }
     }
 }
-let instance$5 = null;
+let instance$6 = null;
 var LegacyReadReceiptSyncEngine = {
     getInstance: () => {
-        if (!instance$5)
-            instance$5 = new LegacyMessageReadReceiptSyncEngine();
-        return instance$5;
+        if (!instance$6)
+            instance$6 = new LegacyMessageReadReceiptSyncEngine();
+        return instance$6;
     },
 };
 
@@ -9112,12 +9139,12 @@ class ObjectResolverEngine {
         this.stopResolver();
     }
 }
-let instance$4 = null;
+let instance$5 = null;
 var ObjectResolverEngine$1 = {
     getInstance: () => {
-        if (!instance$4)
-            instance$4 = new ObjectResolverEngine();
-        return instance$4;
+        if (!instance$5)
+            instance$5 = new ObjectResolverEngine();
+        return instance$5;
     },
 };
 
@@ -9267,13 +9294,13 @@ class LiveReactionSyncEngine {
         this.stopReactionsSync();
     }
 }
-let instance$3;
+let instance$4;
 var ReactionSyncEngine = {
     getInstance: () => {
-        if (!instance$3) {
-            instance$3 = new LiveReactionSyncEngine();
+        if (!instance$4) {
+            instance$4 = new LiveReactionSyncEngine();
         }
-        return instance$3;
+        return instance$4;
     },
 };
 
@@ -9303,19 +9330,20 @@ function prepareBlockedUserPayload(response) {
         }), users: users.map(convertRawUserToInternalUser) });
 }
 
-const BLOCK_LIST_LIMIT = 100;
-const TTL_MS = 5 * 60 * 1000; // 5 minutes
+const BLOCK_LIST_LIMIT$1 = 100;
+const TTL_MS$1 = 5 * 60 * 1000; // 5 minutes
 /**
  * Session-scoped singleton engine that manages TTL-based fetching and caching
  * of blocked users. Provides a lazy `ensureFetched()` gate for the
  * `getAllBlockedUsers()` API.
  *
  * Key behaviours:
- * - `establish()` is a no-op — fetch is lazy, triggered only by consumer call
- * - `destroy()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
+ * - `onSessionEstablished()` is a no-op — fetch is lazy, triggered only by consumer call
+ * - `onSessionDestroyed()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
  * - `ensureFetched()` fetches from server only when cache is expired or never fetched
  * - `lastFetchedAt` is only updated on successful fetch
- * - `blockedUserIds` is kept in sync with each successful fetch
+ * - reads query the follow cache live, so block/unblock changes are reflected
+ *   even within the TTL window
  *
  * @internal
  */
@@ -9323,12 +9351,7 @@ class BlockedUserSyncEngine {
     constructor() {
         /** Epoch ms of last successful fetch. null = never fetched in this session. */
         this.lastFetchedAt = null;
-        /** Ordered list of userId strings from the most recent successful fetch. */
-        this.blockedUserIds = [];
     }
-    // ---------------------------------------------------------------------------
-    // SessionComponent lifecycle
-    // ---------------------------------------------------------------------------
     /** No-op — fetch is lazy, triggered by consumer calling getAllBlockedUsers(). */
     // eslint-disable-next-line class-methods-use-this
     onSessionEstablished() {
@@ -9337,24 +9360,17 @@ class BlockedUserSyncEngine {
     /** Resets state so the next session starts with a cold cache. */
     onSessionDestroyed() {
         this.lastFetchedAt = null;
-        this.blockedUserIds = [];
     }
     /** No-op for this engine. */
     // eslint-disable-next-line class-methods-use-this
     onTokenExpired() {
         // intentionally empty
     }
-    // ---------------------------------------------------------------------------
-    // Cache helpers
-    // ---------------------------------------------------------------------------
     isCacheExpired() {
         if (this.lastFetchedAt === null)
             return true;
-        return Date.now() - this.lastFetchedAt > TTL_MS;
+        return Date.now() - this.lastFetchedAt > TTL_MS$1;
     }
-    // ---------------------------------------------------------------------------
-    // Core fetch gate
-    // ---------------------------------------------------------------------------
     /**
      * Ensures the local store is populated with fresh blocked-user data.
      *
@@ -9370,52 +9386,50 @@ class BlockedUserSyncEngine {
         if (!this.isCacheExpired())
             return;
         const client = getActiveClient();
-        const { data } = await client.http.get('/api/v4/me/user-blocks', { params: { options: { limit: BLOCK_LIST_LIMIT }, isDeleted: false } });
+        const { data } = await client.http.get('/api/v4/me/user-blocks', { params: { options: { limit: BLOCK_LIST_LIMIT$1 }, isDeleted: false } });
         const cachedAt = client.cache && Date.now();
         const payload = prepareBlockedUserPayload(data);
         if (client.cache) {
             ingestInCache(payload, { cachedAt });
         }
-        // Keep the ordered list of blocked user IDs for getCachedUsers()
-        this.blockedUserIds = payload.users.map(u => u.userId);
         // Only update timestamp on success — failure leaves it unchanged so the
         // next call retries.
         this.lastFetchedAt = Date.now();
     }
-    // ---------------------------------------------------------------------------
-    // Local store read
-    // ---------------------------------------------------------------------------
     /**
-     * Returns blocked {@link Amity.InternalUser} objects from the in-memory cache.
-     *
-     * Applies the spec-mandated filter:
-     *  - Only users whose `isDeleted` is false or null
-     *  - Hard limit of 100 results
+     * Returns the blocked users by querying the follow cache live — the outgoing
+     * direction (`from === me`, `status === 'blocked'`). Reading the cache (not a
+     * fetched snapshot) means `blockUser()` / `unblockUser()` changes are reflected
+     * even within the TTL window.
      *
-     * This always reads the latest local state, so changes made by `blockUser()`
-     * and `unblockUser()` are reflected even within the TTL window.
+     * Applies the spec-mandated query:
+     *  - filter `from === currentUserId`, `status === 'blocked'`, blocked user not deleted
+     *  - sort by `updatedAt` DESC
+     *  - hard limit of 100 results
      */
+    // eslint-disable-next-line class-methods-use-this
     getCachedUsers() {
+        var _a;
         const client = getActiveClient();
-        if (!client.cache) {
-            // No cache available — fall back to the in-memory list from the last fetch
+        if (!client.cache)
             return [];
-        }
-        return this.blockedUserIds
-            .map(id => { var _a; return (_a = pullFromCache(['user', 'get', id])) === null || _a === void 0 ? void 0 : _a.data; })
+        const { userId } = client;
+        return ((_a = queryCache(['follow', 'get'])) !== null && _a !== void 0 ? _a : [])
+            .map(entry => entry.data)
+            .filter(follow => (follow === null || follow === void 0 ? void 0 : follow.status) === 'blocked' && follow.from === userId)
+            .sort((a, b) => { var _a, _b; return (((_a = a.updatedAt) !== null && _a !== void 0 ? _a : '') < ((_b = b.updatedAt) !== null && _b !== void 0 ? _b : '') ? 1 : -1); })
+            .map(follow => { var _a; return (_a = pullFromCache(['user', 'get', follow.to])) === null || _a === void 0 ? void 0 : _a.data; })
             .filter((user) => user != null && user.isDeleted !== true)
-            .slice(0, BLOCK_LIST_LIMIT);
+            .slice(0, BLOCK_LIST_LIMIT$1)
+            .map(userLinkedObject);
     }
 }
-// ---------------------------------------------------------------------------
-// Module-level singleton
-// ---------------------------------------------------------------------------
-let instance$2 = null;
+let instance$3 = null;
 var BlockedUserSyncEngine$1 = {
     getInstance: () => {
-        if (!instance$2)
-            instance$2 = new BlockedUserSyncEngine();
-        return instance$2;
+        if (!instance$3)
+            instance$3 = new BlockedUserSyncEngine();
+        return instance$3;
     },
 };
 
@@ -9437,6 +9451,224 @@ var blockedUserSyncEngineOnLoginHandler = () => {
     };
 };
 
+function prepareBlockingUserPayload(response) {
+    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
+    return Object.assign(Object.assign({}, rest), { follows: follows.map(follow => {
+            const followUser = users.find(user => user.userId === follow.from);
+            return Object.assign(Object.assign({}, follow), { user: convertRawUserToInternalUser(followUser) });
+        }), users: users.map(convertRawUserToInternalUser) });
+}
+
+const BLOCK_LIST_LIMIT = 100;
+const TTL_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Session-scoped singleton engine that manages TTL-based fetching and caching
+ * of blocking users (the "blocked-by" list — users who blocked the current
+ * user). Provides a lazy `ensureFetched()` gate for the `getAllBlockingUsers()`
+ * API. Directional inverse of {@link BlockedUserSyncEngine}.
+ *
+ * Key behaviours:
+ * - `onSessionEstablished()` is a no-op — fetch is lazy, triggered only by consumer call
+ * - `onSessionDestroyed()` resets `lastFetchedAt` to null (ensures fresh fetch on next session)
+ * - `ensureFetched()` fetches from server only when cache is expired or never fetched
+ * - `lastFetchedAt` is only updated on successful fetch
+ * - reads query the follow cache live, so block/unblock changes are reflected
+ *   even within the TTL window
+ *
+ * @internal
+ */
+class BlockingUserSyncEngine {
+    constructor() {
+        /** Epoch ms of last successful fetch. null = never fetched in this session. */
+        this.lastFetchedAt = null;
+    }
+    /** No-op — fetch is lazy, triggered by consumer calling getAllBlockingUsers(). */
+    // eslint-disable-next-line class-methods-use-this
+    onSessionEstablished() {
+        // intentionally empty
+    }
+    /** Resets state so the next session starts with a cold cache. */
+    onSessionDestroyed() {
+        this.lastFetchedAt = null;
+    }
+    /** No-op for this engine. */
+    // eslint-disable-next-line class-methods-use-this
+    onTokenExpired() {
+        // intentionally empty
+    }
+    isCacheExpired() {
+        if (this.lastFetchedAt === null)
+            return true;
+        return Date.now() - this.lastFetchedAt > TTL_MS;
+    }
+    /**
+     * Ensures the local store is populated with fresh blocking-user data.
+     *
+     * - If the cache is still within the 5-minute TTL window: resolves immediately
+     *   (no server call).
+     * - If the cache is expired (or never fetched): fetches from the server,
+     *   persists the payload to the cache, and updates `lastFetchedAt`.
+     *
+     * On failure the error propagates to the caller and `lastFetchedAt` is NOT
+     * updated, so the next call will retry.
+     */
+    async ensureFetched() {
+        if (!this.isCacheExpired())
+            return;
+        const client = getActiveClient();
+        const { data } = await client.http.get('/api/v4/me/blockers', { params: { options: { limit: BLOCK_LIST_LIMIT }, isDeleted: false } });
+        const cachedAt = client.cache && Date.now();
+        const payload = prepareBlockingUserPayload(data);
+        if (client.cache) {
+            ingestInCache(payload, { cachedAt });
+        }
+        // Only update timestamp on success — failure leaves it unchanged so the
+        // next call retries.
+        this.lastFetchedAt = Date.now();
+    }
+    /**
+     * Returns the "blocked-by" users by querying the follow cache live — the
+     * incoming direction (`to === me`, `status === 'blocked'`). Reading the cache
+     * (not a fetched snapshot) means RTE `user.didBlock` / `user.didUnblock`
+     * changes are reflected even within the TTL window.
+     *
+     * Applies the spec-mandated query (REQ-012/013/014):
+     *  - filter `to === currentUserId`, `status === 'blocked'`, blocker not deleted
+     *  - sort by `updatedAt` DESC
+     *  - hard limit of 100 results
+     */
+    // eslint-disable-next-line class-methods-use-this
+    getCachedUsers() {
+        var _a;
+        const client = getActiveClient();
+        if (!client.cache)
+            return [];
+        const { userId } = client;
+        return ((_a = queryCache(['follow', 'get'])) !== null && _a !== void 0 ? _a : [])
+            .map(entry => entry.data)
+            .filter(follow => (follow === null || follow === void 0 ? void 0 : follow.status) === 'blocked' && follow.to === userId)
+            .sort((a, b) => { var _a, _b; return (((_a = a.updatedAt) !== null && _a !== void 0 ? _a : '') < ((_b = b.updatedAt) !== null && _b !== void 0 ? _b : '') ? 1 : -1); })
+            .map(follow => { var _a; return (_a = pullFromCache(['user', 'get', follow.from])) === null || _a === void 0 ? void 0 : _a.data; })
+            .filter((user) => user != null && user.isDeleted !== true)
+            .slice(0, BLOCK_LIST_LIMIT)
+            .map(userLinkedObject);
+    }
+}
+let instance$2 = null;
+var BlockingUserSyncEngine$1 = {
+    getInstance: () => {
+        if (!instance$2)
+            instance$2 = new BlockingUserSyncEngine();
+        return instance$2;
+    },
+};
+
+var blockingUserSyncEngineOnLoginHandler = () => {
+    const blockingUserSyncEngine = BlockingUserSyncEngine$1.getInstance();
+    onSessionStateChange(state => {
+        if (state === "established" /* Amity.SessionStates.ESTABLISHED */) {
+            blockingUserSyncEngine.onSessionEstablished();
+        }
+        else if (state === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            blockingUserSyncEngine.onTokenExpired();
+        }
+        else {
+            blockingUserSyncEngine.onSessionDestroyed();
+        }
+    });
+    return () => {
+        blockingUserSyncEngine.onSessionDestroyed();
+    };
+};
+
+function prepareFollowersPayload(response) {
+    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
+    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
+}
+function prepareFollowingsPayload(response) {
+    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
+    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
+}
+function prepareFollowStatusPayload(response) {
+    const { follows } = response, rest = __rest(response, ["follows"]);
+    return Object.assign(Object.assign({}, rest), { follows });
+}
+
+/**
+ * Subscribes to a block MQTT event (`user.didBlock` / `user.didUnblock`),
+ * ingests the carried `FollowersPayload` (follows + users) into the cache so
+ * the block-relationship rows (`['follow', 'get', from#to]`) and user rows are
+ * kept current, then forwards the affected {@link Amity.FollowStatus} to the
+ * caller.
+ *
+ * @hidden
+ */
+const createBlockEventSubscriber = (event, callback) => {
+    const client = getActiveClient();
+    const filter = (data) => {
+        const payload = prepareFollowersPayload(data);
+        if (client.cache) {
+            ingestInCache(payload);
+        }
+        callback(payload.follows[0]);
+    };
+    return createEventSubscriber(client, event, event, filter);
+};
+
+/**
+ * ```js
+ * import { onUserDidBlock } from '@amityco/ts-sdk'
+ * const dispose = onUserDidBlock(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a block relationship is created in real time — either a user
+ * blocks the current user (incoming) or the current user blocks someone on
+ * another device (outgoing). The local block-relationship store is updated
+ * before the callback runs.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Block Events
+ */
+const onUserDidBlock = (callback) => createBlockEventSubscriber('user.didBlock', callback);
+
+/**
+ * ```js
+ * import { onUserDidUnblock } from '@amityco/ts-sdk'
+ * const dispose = onUserDidUnblock(status => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a block relationship is removed in real time — either a user
+ * unblocks the current user (incoming) or the current user unblocks someone on
+ * another device (outgoing). The local block-relationship store is updated
+ * before the callback runs.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Block Events
+ */
+const onUserDidUnblock = (callback) => createBlockEventSubscriber('user.didUnblock', callback);
+
+/**
+ * Keeps the follow cache current for incoming/outgoing block changes for the
+ * whole session — the ingest happens as a side effect inside
+ * createBlockEventSubscriber, so the one-shot `getAllBlockedUsers()` /
+ * `getAllBlockingUsers()` reflect RTE block/unblock within the TTL window.
+ *
+ * Registered via `setupLoginSubscriptions`; the returned unsubscriber is torn
+ * down on logout.
+ */
+var blockRealtimeOnLoginHandler = () => {
+    const disposers = [onUserDidBlock(() => { }), onUserDidUnblock(() => { })];
+    return () => disposers.forEach(dispose => dispose());
+};
+
 class CursorController {
     constructor(networkId, userId) {
         this.networkId = networkId;
@@ -9476,7 +9708,11 @@ class CursorController {
             const parsed = JSON.parse(raw);
             if (typeof (parsed === null || parsed === void 0 ? void 0 : parsed.cursor) !== 'string' || typeof (parsed === null || parsed === void 0 ? void 0 : parsed.expiredAt) !== 'number')
                 return null;
-            return { cursor: parsed.cursor, expiredAt: parsed.expiredAt };
+            return {
+                cursor: parsed.cursor,
+                expiredAt: parsed.expiredAt,
+                reachedEndOfFeed: parsed.reachedEndOfFeed === true,
+            };
         }
         catch (_a) {
             return null;
@@ -9485,6 +9721,15 @@ class CursorController {
     async set(value) {
         await setItem(this.key, JSON.stringify(value));
     }
+    async markReachedEndOfFeed(expiredAt) {
+        var _a;
+        const stored = await this.get();
+        await this.set({
+            cursor: (_a = stored === null || stored === void 0 ? void 0 : stored.cursor) !== null && _a !== void 0 ? _a : '',
+            expiredAt,
+            reachedEndOfFeed: true,
+        });
+    }
     async clear() {
         await setItem(this.key, '');
     }
@@ -9679,7 +9924,7 @@ const setupLoginSubscriptions = (unsubWatcher) => {
     // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
     // the channel because currently backend can't handle this, so every time a user is banned from
     // a channel or the channel is deleted the channel's unread count will not be reset to zero
-    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout());
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), blockingUserSyncEngineOnLoginHandler(), blockRealtimeOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout());
     if (client.useLegacyUnreadCount) {
         subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
@@ -10764,12 +11009,13 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
         getSocialSettings,
         getChatSettings,
         getVisitorDeviceId: getDeviceId,
-        getMessagePreviewSetting,
+        getMessagePreviewSetting: getMessagePreviewSetting$1,
         use: () => setActiveClient(client),
         isUnreadCountEnabled,
         useLegacyUnreadCount,
         getMarkerSyncConsistentMode,
         getProductCatalogueSetting,
+        getForYouFeedSetting,
         /**
          * Prefix for the deviceId key in the local storage or async storage.
          * This is allow user to have multiple SDK client and Mqtt client within the same app.
@@ -11845,6 +12091,7 @@ var index$s = /*#__PURE__*/Object.freeze({
     getSocialSettings: getSocialSettings,
     getShareableLinkConfiguration: getShareableLinkConfiguration,
     getProductCatalogueSetting: getProductCatalogueSetting,
+    getForYouFeedSetting: getForYouFeedSetting,
     loginAsVisitor: loginAsVisitor,
     loginAsBot: loginAsBot,
     getCurrentUser: getCurrentUser,
@@ -11874,19 +12121,6 @@ var index$s = /*#__PURE__*/Object.freeze({
     getMarkerSyncConsistentMode: getMarkerSyncConsistentMode
 });
 
-function prepareFollowersPayload(response) {
-    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
-    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
-}
-function prepareFollowingsPayload(response) {
-    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
-    return Object.assign(Object.assign({}, rest), { follows, users: users.map(convertRawUserToInternalUser) });
-}
-function prepareFollowStatusPayload(response) {
-    const { follows } = response, rest = __rest(response, ["follows"]);
-    return Object.assign(Object.assign({}, rest), { follows });
-}
-
 /* begin_public_function
   id: user.relationship.block
 */
@@ -11962,75 +12196,14 @@ const unBlockUser = async (userId) => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: user.relationship.follow
+*/
 /**
- * Subscribes to a block MQTT event (`user.didBlock` / `user.didUnblock`),
- * ingests the carried `FollowersPayload` (follows + users) into the cache so
- * the block-relationship rows (`['follow', 'get', from#to]`) and user rows are
- * kept current, then forwards the affected {@link Amity.FollowStatus} to the
- * caller.
- *
- * @hidden
- */
-const createBlockEventSubscriber = (event, callback) => {
-    const client = getActiveClient();
-    const filter = (data) => {
-        const payload = prepareFollowersPayload(data);
-        if (client.cache) {
-            ingestInCache(payload);
-        }
-        callback(payload.follows[0]);
-    };
-    return createEventSubscriber(client, event, event, filter);
-};
-
-/**
- * ```js
- * import { onUserDidBlock } from '@amityco/ts-sdk'
- * const dispose = onUserDidBlock(status => {
- *   // ...
- * })
- * ```
- *
- * Fired when a block relationship is created in real time — either a user
- * blocks the current user (incoming) or the current user blocks someone on
- * another device (outgoing). The local block-relationship store is updated
- * before the callback runs.
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Block Events
- */
-const onUserDidBlock = (callback) => createBlockEventSubscriber('user.didBlock', callback);
-
-/**
- * ```js
- * import { onUserDidUnblock } from '@amityco/ts-sdk'
- * const dispose = onUserDidUnblock(status => {
- *   // ...
- * })
- * ```
- *
- * Fired when a block relationship is removed in real time — either a user
- * unblocks the current user (incoming) or the current user unblocks someone on
- * another device (outgoing). The local block-relationship store is updated
- * before the callback runs.
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Block Events
- */
-const onUserDidUnblock = (callback) => createBlockEventSubscriber('user.didUnblock', callback);
-
-/* begin_public_function
-  id: user.relationship.follow
-*/
-/**
- * ```js
- * import { follow } from '@amityco/ts-sdk'
- * const status = await follow('foobar')
- * ```
+ * ```js
+ * import { follow } from '@amityco/ts-sdk'
+ * const status = await follow('foobar')
+ * ```
  *
  * Follow the user
  *
@@ -13956,7 +14129,7 @@ const getWatchSessionStorage = () => {
     return storageInstance;
 };
 
-const privateKey = "MIIEpQIBAAKCAQEAwAEc/oZgYIvKSUG/C3mONYLR4ZPgAjMEX4bJ+xqqakUDRtqlNO+eZs2blQ1Ko0DBkqPExyQezvjibH5W2UZBV5RaBTlTcNVKTToMBEGesAfaEcM3qUyQHxdbFYZv6P4sb14dcwxTQ8usmaV8ooiR1Fcaso5ZWYcZ8Hb46FbQ7OoVumsBtPWwfZ4f003o5VCl6AIM6lcLv9UDLlFVYhE+PeXpRHtfWlGqxMvqC9oinlwhL6nWv6VjQXW4nhcib72dPBzfHT7k/PMKto2SxALYdb68ENiAGuJLWi3AUHSyYCJK2w7wIlWfJUAI0v26ub10IpExr6D5QuW2577jjP93iwIDAQABAoIBAFWfqXhwIIatkFY+9Z1+ZcbDQimgsmMIsUiQaX6Lk7e0cxOj6czDlxYtVtaPiNtow2pLkjNkjkCqiP7tEHnwdK9DvylZOTa2R15NJpK3WLcTqVIGhsn/FL5owfvFah6zSsmXZParZm5zY9NZE03ALZhOB9/cz0e3kf/EbpfeL2mW7MApyiUt5i09ycchroOpcWp73ipIxvgigtZyUGFmsQicWhUs28F0D7w4Qfk76yG3nqXeb+BAMhCaIaa/k/aAxhiZG/ygEQWQrcC8gfe+jyicMAQPDEVS9YuUMGsLjIjKuVLZzp2xirQnhc2i2zVNEIvG6soprPOBEMQugzrtX5ECgYEA3b7KAbBIbDl1e4ZSCWhHdHkiWVZHaopsR/LhqDDNhXjWjq3AesgV6k0j9EdziMn/HmmOso0bz99GTV3JZf4A9ztTLumJlkHbdVtlgOqSjrFLj12rH9KXTheyIhWSpUmm8+WB1xasFbqpvJaGo7F3pd2Fqj1XR4mp5BO7c/t7LJ0CgYEA3aouEzXQ9THRKYocdfY69EI1Il1t/d/RSqqd9BxEjxBgxkM13ZiYIn/R4WW/nCUrlmhxG44Aa2Gob4Ahfsui2xKTg/g/3Zk/rAxAEGkfOLGoenaJMD41fH4wUq3FRYwkvnaMb9Hd6f/TlBHslIRa2NN58bSBGJCyBP2b59+2+EcCgYEAixDVRXvV37GlYUOa/XVdosk5Zoe6oDGRuQm0xbNdoUBoZvDHDvme7ONWEiQha/8qtVsD+CyQ7awcPfb8kK9c0bBt+bTS6d4BkTcxkEkMgtrkBVR8Nqfu5jXsLH4VCv4G61zbMhZw8+ut+az5YX2yCN7Frj9sFlxapMRPQmzMEe0CgYEAumsAzM8ZqNv4mAK65Mnr0rhLj1cbxcKRdUYACOgtEFQpzxN/HZnTeFAe5nx3pI3uFlRHq3DFEYnT6dHMWaJQmAULYpVIwMi9L6gtyJ9fzoI6uqMtxRDMUqKdaSsTGOY/kJ6KhQ/unXi1K3XXjR+yd1+C0q+HUm1+CYxvrZYLfskCgYEArsEy+IQOiqniJ0NE2vVUF+UK/IRZaic9YKcpov5Ot7Vvzm/MnnW4N1ljVskocETBWMmPUvNSExVjPebi+rxd8fa5kY8BJScPTzMFbunZn/wjtGdcM10qdlVQ9doG61A/9P3ezFKCfS4AvF/H/59LcSx2Bh28fp3/efiVIOpVd4Y=";
+const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHo80SecH7FuF2\nhFYnb+l26/VN8UMLXAQFLnxciNTEwkGVFMpdezlH8rU2HtUJL4RETogbAOLVY0XM\njs6sPn8G1nALmh9qeDpUtVqFOVtBHxEZ910TLOtQiunjqJKO5nWdqZ71EC3OFluR\niGQkO84BiIFbv37ub7xl3S8XarbtKoLcyVpkDHi+1wx1pgCAn6gtBUgckPL5NR8j\nLseabl3HAXQfhTCKo4tmOFM2Dxwl1IUMmIJrJg/aIU/U0tj/1Eoo7mG0JcNWX19l\nW3EecCbi0ncCJOrkUdwlBrcjaMayaX/ubEwyUeTGiLdyc4L3GRLHjyK8xgVNXRMH\nbZWJ2a5NAgMBAAECggEASxuE+35zTFO/XydKgmvIGcWL9FbgMlXb7Vcf0nBoG945\nbiz0NVc2paraIhJXc608xbYF3qLmtAE1MVBI0ORyRdBHNxY024l/6H6SH60Ed+uI\nM4ysp5ourY6Vj+DLwpdRiI9YDjqYAQDIUmhNxJP7XPhOMoZI6st+xZQBM34ic/bv\nAMSJm9OZphSp3+qXVkFZztr2mxD2EZSJJLYxi8BCdgM2qhazalbcJ6zDKHCZWVWm\n8RRxDGldyMb/237JxETzP40tAlzOZDmBAbUgEnurDJ93RVDIE3rbZUshwgeQd18a\nem096mWgvB1AIKYgsTAR3pw+V19YWAjq/glP6fz8wQKBgQD/oQq+ukKF0PRgBeM5\ngeTjSwsdGppQLmf5ndujvoiz/TpdjDEPu6R8kigQr1rG2t4K/yfdZoI8RdmJD1al\n3Q7N9hofooSy4rj6E3txzWZCHJjHad2cnCp/O26HiReGAl7wTcfTmNdiFHhZQzm5\nJBkvWAiwuvQMNfEbnXxw6/vIDwKBgQDH7fX8gsc77JLvAWgp1MaQN/sbqVb6JeT1\nFQfR8E/WFCSmzQBtNzd5KgYuCeelwr/8DyYytvN2BzCYZXp73gI1jF3YlW5jVn74\nOY6TwQ095digwo6Z0yuxopdIOApKgAkL9PRKgNrqAf3NAyMua6lOGifzjDojC3KU\nfylQmxMn4wKBgHp2B9O/H0dEBw5JQ8W0+JX6yWQz7mEjGiR2/1W+XXb8hQ1zr709\nw1r6Gb+EghRpnZ3fBpYGGbYOMFx8wKHM+N6qW3F0ReX8v2juFGE8aRSa5oYBrWzt\nU16Idjbv8hj84cZ1PJmdyvDtpYn9rpWHOZl4rxEbPvbqkIsOMyNVqdT5AoGAOSge\nmwIIU2le2FVeohbibXiToWTYKMuMmURZ5/r72AgKMmWJKbAPe+Q3wBG01/7FRBpQ\noU8Ma0HC8s6QJbliiEyIx9JwrJWd1vkdecBHONrtA4ibm/5zD2WcOllLF+FitLhi\n3qnX6+6F0IaFGFBPJrTzlv0P4dTz/OAdv52V7GECgYEA2TttOKBAqWllgOaZOkql\nLVMJVmgR7s6tLi1+cEP8ZcapV9aRbRzTAKXm4f8AEhtlG9F9kCOvHYCYGi6JaiWJ\nZkHjeex3T+eE6Di6y5Bm/Ift5jtVhJ4jCVwHOKTMej79NPUFTJfv8hCo29haBDv6\nRXFrv+T21KCcw8k3sJeJWWQ=\n-----END PRIVATE KEY-----";
 /*
  * The crypto algorithm used for importing key and signing string
  */
@@ -16505,7 +16678,38 @@ const getAllBlockedUsers = async () => {
     const engine = BlockedUserSyncEngine$1.getInstance();
     // Ensure data is fetched (no-op if cache is fresh)
     await engine.ensureFetched();
-    // Read from the engine's bounded ID list — O(blocked users) not O(cache size)
+    return engine.getCachedUsers();
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: user.get_all_blocking_users
+*/
+/**
+ * ```js
+ * import { UserRepository } from '@amityco/ts-sdk'
+ * const blockingUsers = await UserRepository.getAllBlockingUsers()
+ * ```
+ *
+ * Returns all users who have blocked the current user
+ * non-paginated list (limit 100) with TTL-based caching (5-minute window). Within the
+ * TTL window, subsequent calls resolve instantly from the local store without any
+ * server call. After the TTL expires, the next call triggers a fresh server fetch.
+ *
+ * The directional inverse of {@link getAllBlockedUsers}.
+ *
+ * @returns A promise that resolves to an array of blocking {@link Amity.User} objects
+ *
+ * @category Block API
+ * @async
+ */
+const getAllBlockingUsers = async () => {
+    const client = getActiveClient();
+    client.log('user/getAllBlockingUsers');
+    const engine = BlockingUserSyncEngine$1.getInstance();
+    // Ensure data is fetched (no-op if cache is fresh)
+    await engine.ensureFetched();
+    // Read from the engine's bounded ID list — O(blocking users) not O(cache size)
     return engine.getCachedUsers();
 };
 /* end_public_function */
@@ -17084,14 +17288,6 @@ const getBlockedUsers = (params, callback, config) => {
 };
 /* end_public_function */
 
-function prepareBlockingUserPayload(response) {
-    const { users, follows } = response, rest = __rest(response, ["users", "follows"]);
-    return Object.assign(Object.assign({}, rest), { follows: follows.map(follow => {
-            const followUser = users.find(user => user.userId === follow.from);
-            return Object.assign(Object.assign({}, follow), { user: convertRawUserToInternalUser(followUser) });
-        }), users: users.map(convertRawUserToInternalUser) });
-}
-
 class BlockingUserQueryStreamController extends QueryStreamController {
     constructor(query, cacheKey, notifyChange, preparePayload) {
         super(query, cacheKey);
@@ -17536,6 +17732,7 @@ var index$q = /*#__PURE__*/Object.freeze({
     unflagUser: unflagUser,
     isUserFlaggedByMe: isUserFlaggedByMe,
     getAllBlockedUsers: getAllBlockedUsers,
+    getAllBlockingUsers: getAllBlockingUsers,
     onUserUpdated: onUserUpdated,
     onUserDeleted: onUserDeleted$2,
     onUserFlagged: onUserFlagged,
@@ -23645,6 +23842,405 @@ const getArchivedChannels = (params, callback) => {
 };
 /* end_public_function */
 
+class SearchChannelPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { query, exactMatch, isMemberOnly, types, tags, sortBy, orderBy, limit = COLLECTION_DEFAULT_PAGINATION_SIZE, } = queryParams;
+        const options = token ? { token } : { limit: Math.min(100, Math.max(1, limit)) };
+        const { data: queryResponse } = await this.http.get(`/api/v2/search/channels`, {
+            params: {
+                query,
+                exactMatch,
+                isMemberOnly,
+                types,
+                tags,
+                sortBy,
+                orderBy,
+                options,
+            },
+        });
+        return queryResponse;
+    }
+}
+
+class SearchChannelQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = await prepareChannelPayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: response.channels.map(getResolver('channel')),
+            });
+            return;
+        }
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        const existing = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+        const incoming = response.channels.map(getResolver('channel'));
+        pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: direction === "prev" /* Amity.LiveCollectionPageDirection.PREV */
+                ? [...new Set([...incoming, ...existing])]
+                : [...new Set([...existing, ...incoming])] }));
+    }
+    reactor() {
+        return () => this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor()));
+    }
+}
+
+/* eslint-disable no-use-before-define */
+const getMessagePreviewSetting = () => {
+    const client = getActiveClient();
+    return client.getMessagePreviewSetting(false);
+};
+class SearchChannelLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['channel', 'search', queryStreamId];
+        const paginationController = new SearchChannelPaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.queryStreamController = new SearchChannelQueryStreamController(query, this.cacheKey, this.notifyChange.bind(this));
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    startSubscription() {
+        return this.queryStreamController.subscribeRTE(this.getSubscriptions());
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a, _b;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = (_b = collection.data
+            .map(channelId => pullFromCache(['channel', 'get', channelId]))
+            .filter(Boolean)
+            .map(cached => constructChannelObject(cached.data))) !== null && _b !== void 0 ? _b : [];
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+    setup() {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection) {
+            pushToCache(this.cacheKey, {
+                data: [],
+                params: {},
+            });
+        }
+    }
+    async persistModel(response) {
+        await this.queryStreamController.saveToMainDB(response);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    shouldAbort(targetChannelId) {
+        var _a;
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return true;
+        return !collection.data.find(channelId => channelId === targetChannelId);
+    }
+    getSubscriptions() {
+        return [
+            {
+                fn: convertEventPayload((callback) => {
+                    return onMessageCreatedMqtt(message => {
+                        var _a;
+                        const cacheData = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!cacheData)
+                            return;
+                        updateChannelCache(cacheData, {
+                            lastActivity: message.createdAt,
+                        });
+                        callback(message);
+                    });
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    return onMessageCreatedLocal(message => {
+                        var _a;
+                        const cacheData = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!cacheData)
+                            return;
+                        updateChannelCache(cacheData, {
+                            lastActivity: message.createdAt,
+                        });
+                        callback(message);
+                    });
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            { fn: onChannelDeleted, action: "onDelete" /* Amity.ChannelActionType.OnDelete */ },
+            { fn: onChannelUpdated, action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */ },
+            { fn: onChannelSetMuted, action: "onMute" /* Amity.ChannelActionType.OnMute */ },
+            {
+                fn: (reactor) => onChannelArchived(payload => {
+                    const channels = payload.archives
+                        .map(archive => {
+                        var _a;
+                        return (_a = pullFromCache(['channel', 'get', archive.channelId])) === null || _a === void 0 ? void 0 : _a.data;
+                    })
+                        .filter((c) => Boolean(c));
+                    if (channels.length > 0)
+                        reactor(channels);
+                }),
+                action: "onArchived" /* Amity.ChannelActionType.OnArchived */,
+            },
+            {
+                fn: (reactor) => onChannelUnarchived(payload => {
+                    const channels = payload.archives
+                        .map(archive => {
+                        var _a;
+                        return (_a = pullFromCache(['channel', 'get', archive.channelId])) === null || _a === void 0 ? void 0 : _a.data;
+                    })
+                        .filter((c) => Boolean(c));
+                    if (channels.length > 0)
+                        reactor(channels);
+                }),
+                action: "onUnarchived" /* Amity.ChannelActionType.OnUnarchived */,
+            },
+            {
+                fn: convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        var _a;
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageCreated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        const channel = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!channel)
+                            return;
+                        updateChannelCache(channel, {
+                            messagePreviewId: message.messageId,
+                        });
+                        callback(message);
+                    };
+                    return onMessageCreatedMqtt(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        var _a;
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageCreated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        const channel = (_a = pullFromCache([
+                            'channel',
+                            'get',
+                            message.channelId,
+                        ])) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!channel)
+                            return;
+                        updateChannelCache(channel, {
+                            messagePreviewId: message.messageId,
+                        });
+                        callback(message);
+                    };
+                    return onMessageCreatedLocal(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        handleMessageUpdated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        callback(message);
+                    };
+                    return onMessageUpdated(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (message) => {
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        if (messagePreviewSetting ===
+                            "message-preview-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_INCLUDE_DELETED */)
+                            await handleMessageUpdated(message);
+                        if (this.shouldAbort(message.channelId))
+                            return;
+                        if (messagePreviewSetting ===
+                            "message-preview-not-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED */) {
+                            await getChannel$1(message.channelId);
+                        }
+                        callback(message);
+                    };
+                    return onMessageDeleted(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (subChannel) => {
+                        var _a;
+                        const collections = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!collections)
+                            return;
+                        const channelId = collections.data.find(channel => {
+                            const messagePreviewCache = getChannelMessagePreview(channel);
+                            return (messagePreviewCache === null || messagePreviewCache === void 0 ? void 0 : messagePreviewCache.subChannelId) === subChannel.subChannelId;
+                        });
+                        if (!channelId)
+                            return;
+                        await getChannel$1(subChannel.channelId);
+                        callback(subChannel);
+                    };
+                    return onSubChannelDeleted(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const updateMessagePreview = async (subChannel) => {
+                        var _a;
+                        const messagePreviewSetting = await getMessagePreviewSetting();
+                        if (messagePreviewSetting === "no-message-preview" /* Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW */)
+                            return;
+                        const collections = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                        if (!collections)
+                            return;
+                        await handleSubChannelUpdated(subChannel);
+                        if (this.shouldAbort(subChannel.channelId))
+                            return;
+                        callback(subChannel);
+                    };
+                    return onSubChannelUpdated(updateMessagePreview);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: (callback) => {
+                    const handleUserFeedMarkerResolved = async (marker) => {
+                        if (marker.feedMarkers) {
+                            const channels = marker.feedMarkers
+                                .map(feedMarker => {
+                                var _a;
+                                return (_a = pullFromCache([
+                                    'channel',
+                                    'get',
+                                    feedMarker.entityId,
+                                ])) === null || _a === void 0 ? void 0 : _a.data;
+                            })
+                                .filter(Boolean);
+                            callback(channels);
+                        }
+                    };
+                    return onUserMessageFeedMarkerResolved(handleUserFeedMarkerResolved);
+                },
+                action: "OnResolveUnread" /* Amity.ChannelActionType.OnResolveUnread */,
+            },
+            {
+                fn: convertEventPayload(onChannelUnreadInfoUpdatedLocal, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+            {
+                fn: convertEventPayload((callback) => {
+                    const processPayload = (payloads) => {
+                        payloads.forEach(callback);
+                    };
+                    return onChannelUnreadUpdatedLocal(processPayload);
+                }, 'channelId', 'channel'),
+                action: "onUpdate" /* Amity.ChannelActionType.OnUpdate */,
+            },
+        ];
+    }
+}
+
+/* begin_public_function
+  id: channel.search
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk';
+ *
+ * const unsubscribe = ChannelRepository.searchChannels(
+ *   { query: 'hello' },
+ *   response => response.data,
+ * );
+ * ```
+ *
+ * Live collection of {@link Amity.Channel}s matching the search query. Backed by
+ * `GET /api/v2/search/channels`.
+ *
+ * @param params Search parameters.
+ * @param callback Called whenever new data are available.
+ * @returns An {@link Amity.Unsubscriber} function to stop observing.
+ *
+ * @category Channel Live Collection
+ */
+const searchChannels = (params, callback) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        console.log(ENABLE_CACHE_MESSAGE);
+    const timestamp = Date.now();
+    log(`searchChannels(tmpid: ${timestamp}) > listen`);
+    const searchChannelLiveCollection = new SearchChannelLiveCollectionController(params, callback);
+    const disposers = searchChannelLiveCollection.startSubscription();
+    const cacheKey = searchChannelLiveCollection.getCacheKey();
+    disposers.push(() => {
+        dropFromCache(cacheKey);
+    });
+    return () => {
+        log(`searchChannels(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
 /* begin_public_function
   id: channel.member.add
 */
@@ -24278,6 +24874,7 @@ var index$j = /*#__PURE__*/Object.freeze({
     getChannels: getChannels,
     getTotalChannelsUnread: getTotalChannelsUnread,
     getArchivedChannels: getArchivedChannels,
+    searchChannels: searchChannels,
     MARKER_INCLUDED_CHANNEL_TYPE: MARKER_INCLUDED_CHANNEL_TYPE,
     isUnreadCountSupport: isUnreadCountSupport,
     convertFromRaw: convertFromRaw,
@@ -29349,45 +29946,80 @@ class ForYouFeedPaginationController extends PaginationController {
     constructor(query) {
         super(query);
         this.checkedDisk = false;
+        this.hasDeliveredPost = false;
         this.cursor = CursorController.current();
     }
     async getRequest(_queryParams, token) {
-        let effectiveToken = token;
-        if (!effectiveToken && !this.checkedDisk && this.cursor) {
+        var _a, _b, _c, _d, _e;
+        const isFirstPage = token === undefined;
+        let stored = null;
+        // On the first page of a fresh collection, load the saved cursor from disk once.
+        // Drop it if the snapshot has already expired so we start fresh.
+        if (isFirstPage && !this.checkedDisk && this.cursor) {
             this.checkedDisk = true;
-            const stored = await this.cursor.get();
-            if (stored && !CursorController.isExpired(stored.expiredAt)) {
-                effectiveToken = stored.cursor;
-            }
-            else if (stored) {
+            stored = await this.cursor.get();
+            if (stored && CursorController.isExpired(stored.expiredAt)) {
                 await this.cursor.clear();
+                stored = null;
             }
         }
-        const options = {
-            limit: COLLECTION_DEFAULT_PAGINATION_SIZE,
-        };
-        if (effectiveToken)
-            options.token = effectiveToken;
-        let queryResponse;
+        // Already paged to the end before. Ask the BE fresh (no cursor) and check if it's
+        // still the same snapshot the user finished.
+        if (isFirstPage && (stored === null || stored === void 0 ? void 0 : stored.reachedEndOfFeed)) {
+            const fresh = await this.fetch();
+            const freshExpiredAt = Date.parse((_b = (_a = fresh.paging) === null || _a === void 0 ? void 0 : _a.expiredAt) !== null && _b !== void 0 ? _b : '');
+            const rolledOver = !Number.isNaN(freshExpiredAt) && freshExpiredAt !== stored.expiredAt;
+            // New snapshot → serve it. Same snapshot → user has seen it all, show empty.
+            if (rolledOver) {
+                await this.persistCursor(fresh);
+                if (fresh.posts.length > 0)
+                    this.hasDeliveredPost = true;
+                return fresh;
+            }
+            return Object.assign(Object.assign({}, fresh), { posts: [], paging: {} });
+        }
+        // Resume from the saved cursor on re-entry; otherwise use the live-collection token.
+        const effectiveToken = isFirstPage && stored ? stored.cursor : token;
+        const response = await this.fetch(effectiveToken);
+        if (response.posts.length > 0)
+            this.hasDeliveredPost = true;
+        if ((_c = response.paging) === null || _c === void 0 ? void 0 : _c.next) {
+            // More pages left → advance the saved cursor.
+            await this.persistCursor(response);
+        }
+        else if (this.hasDeliveredPost && this.cursor) {
+            // Reached the end and mark end of feed
+            const expiredAt = Date.parse((_e = (_d = response.paging) === null || _d === void 0 ? void 0 : _d.expiredAt) !== null && _e !== void 0 ? _e : '');
+            if (!Number.isNaN(expiredAt))
+                await this.cursor.markReachedEndOfFeed(expiredAt);
+        }
+        return response;
+    }
+    async fetch(token) {
+        const options = { limit: COLLECTION_DEFAULT_PAGINATION_SIZE };
+        if (token)
+            options.token = token;
         try {
-            ({ data: queryResponse } = await this.http.get(API_ENDPOINTS.forYouFeed, { params: { options } }));
+            const { data } = await this.http.get(API_ENDPOINTS.forYouFeed, {
+                params: { options },
+            });
+            return data;
         }
         catch (error) {
             if (error instanceof ASCApiError && error.code === 400300 /* Amity.ServerError.FORBIDDEN */) {
                 throw new AmityForYouFeedDisabledError();
             }
             const recoverable = error instanceof ASCApiError && error.code === 400322 /* Amity.ServerError.FEED_SNAPSHOT_EXPIRED */;
-            if (recoverable && effectiveToken !== undefined) {
+            if (recoverable && token !== undefined) {
                 if (this.cursor)
                     await this.cursor.clear();
-                ({ data: queryResponse } = await this.http.get(API_ENDPOINTS.forYouFeed, { params: { options: { limit: COLLECTION_DEFAULT_PAGINATION_SIZE } } }));
-            }
-            else {
-                throw error;
+                const { data } = await this.http.get(API_ENDPOINTS.forYouFeed, {
+                    params: { options: { limit: COLLECTION_DEFAULT_PAGINATION_SIZE } },
+                });
+                return data;
             }
+            throw error;
         }
-        await this.persistCursor(queryResponse);
-        return queryResponse;
     }
     async persistCursor(response) {
         var _a, _b;