@amityco/ts-sdk 7.27.0 → 7.27.1-075c277.0

package/dist/index.cjs.js

@@ -7,8 +7,9 @@ var mitt = require('mitt');
 var debug = require('debug');
 var axios = require('axios');
 var HttpAgent = require('agentkeepalive');
-var mqtt = require('mqtt');
 var uuid$1 = require('react-native-uuid');
+var mqtt = require('mqtt');
+var uaParserJs = require('ua-parser-js');
 var jwtDecode = require('jwt-decode');
 var hash = require('object-hash');
 var Hls = require('hls.js');
@@ -19,8 +20,8 @@ var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var HttpAgent__default = /*#__PURE__*/_interopDefaultLegacy(HttpAgent);
-var mqtt__default = /*#__PURE__*/_interopDefaultLegacy(mqtt);
 var uuid__default = /*#__PURE__*/_interopDefaultLegacy(uuid$1);
+var mqtt__default = /*#__PURE__*/_interopDefaultLegacy(mqtt);
 var jwtDecode__default = /*#__PURE__*/_interopDefaultLegacy(jwtDecode);
 var hash__default = /*#__PURE__*/_interopDefaultLegacy(hash);
 var Hls__default = /*#__PURE__*/_interopDefaultLegacy(Hls);
@@ -341,6 +342,7 @@ function getVersion() {
 const VERSION = getVersion();
 
 const COLLECTION_DEFAULT_PAGINATION_LIMIT = 5;
+const LATEST_COMMENTS_LIMIT = 5;
 const COLLECTION_DEFAULT_PAGINATION_SIZE = 20;
 const COLLECTION_DEFAULT_CACHING_POLICY = 'cache_then_server';
 const ENABLE_CACHE_MESSAGE = 'For using Live Collection feature you need to enable Cache!';
@@ -356,7 +358,11 @@ const YEAR = 365 * DAY;
 const ACCESS_TOKEN_WATCHER_INTERVAL = 10 * MINUTE;
 const API_ENDPOINTS = {
     forYouFeed: '/api/v1/feeds/for-you',
+    commentReviewQueue: (communityId) => `/api/v3/communities/${encodeURIComponent(communityId)}/comments/review-queue`,
 };
+// The review-queue route defaults to 10, not the SDK-wide page size, and caps at 100
+const COMMENT_REVIEW_QUEUE_DEFAULT_PAGINATION_SIZE = 10;
+const COMMENT_REVIEW_QUEUE_MAX_PAGINATION_SIZE = 100;
 
 // cache constants
 const CACHE_KEY_GET = 'get';
@@ -1953,6 +1959,8 @@ function computeUrl(type, region) {
     return URLS[type].replace('{region}', region);
 }
 
+const uuid = () => uuid__default["default"].v4().toString();
+
 /**
  * Unwraps v3 server payload (for error handling and type extraction)
  *
@@ -1977,6 +1985,24 @@ const unwrapPayload = (response) => {
     // unjust, but helps force uncast "T | undefined" to allow deconstruction without warnings
     return undefined;
 };
+/**
+ * Builds a hex string of `bytes` length from the SDK's uuid helper (a v4 UUID is
+ * 16 bytes / 32 hex chars once hyphens are removed) — avoids a new crypto dependency.
+ */
+const randomHex = (bytes) => {
+    let hex = '';
+    while (hex.length < bytes * 2)
+        hex += uuid().replace(/-/g, '');
+    return hex.slice(0, bytes * 2);
+};
+/**
+ * W3C Trace Context `traceparent`: `version-<16-byte trace-id>-<8-byte span-id>-<flags>`.
+ * The SDK is the trace originator, so it mints a fresh trace + span id per request; flags `01` = sampled.
+ *
+ * @category Transport
+ * @hidden
+ */
+const generateTraceparent = () => `00-${randomHex(16)}-${randomHex(8)}-01`;
 
 class NetworkActivitiesWatcher {
     constructor() {
@@ -2101,6 +2127,10 @@ const createHttpTransport = (endpoint) => {
     });
     instance.defaults.withCredentials = false;
     instance.interceptors.request.use(config => {
+        // Request tracing — set on every outbound request (login included), never persisted.
+        // Must run before the session-url early-return below so /api/v5/sessions carries them too.
+        config.headers.set('x-request-id', uuid());
+        config.headers.set('traceparent', generateTraceparent());
         // do not check expiration for token creation url
         if (config.url === '/api/v5/sessions') {
             return config;
@@ -2144,20 +2174,28 @@ const createHttpTransport = (endpoint) => {
         });
         return response;
     }, error => {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         const { response } = error;
         // handle unauthorized request
         if ((response === null || response === void 0 ? void 0 : response.data.code) === 400100 /* Amity.ServerError.UNAUTHORIZED */) {
             fireEvent('tokenTerminated', "terminated" /* Amity.SessionStates.TERMINATED */);
         }
+        // handle globally banned user. The realtime `user.didGlobalBan` event can be missed
+        // (e.g. MQTT dropped before delivery), so mirror the 400100 handling above and fire
+        // the same virtual event the login subscriptions already listen to. That terminates
+        // the session with `TokenTerminationReason.GLOBAL_BAN` and notifies `onClientBanned`
+        // consumers, instead of leaving the session `established` with a revoked token.
+        if (((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.code) === 400312 /* Amity.ServerError.GLOBAL_BAN */) {
+            fireEvent('user.didGlobalBan', { users: [], files: [] });
+        }
         // handle visitor daily usage limit exceeded
-        if (((_a = response === null || response === void 0 ? void 0 : response.data) === null || _a === void 0 ? void 0 : _a.code) === 400323 /* Amity.ServerError.VISITOR_USAGE_LIMIT_EXCEEDED */) {
+        if (((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.code) === 400323 /* Amity.ServerError.VISITOR_USAGE_LIMIT_EXCEEDED */) {
             throttledFireVisitorUsageLimit();
             throw new ASCError('Visitor usage limit exceeded', 400323 /* Amity.ServerError.VISITOR_USAGE_LIMIT_EXCEEDED */, "error" /* Amity.ErrorLevel.ERROR */);
         }
         // if it's an error with status in the response payload,
         // then it's an expected error.
-        if ((_b = response === null || response === void 0 ? void 0 : response.data) === null || _b === void 0 ? void 0 : _b.status) {
+        if ((_c = response === null || response === void 0 ? void 0 : response.data) === null || _c === void 0 ? void 0 : _c.status) {
             unwrapPayload(response === null || response === void 0 ? void 0 : response.data);
         }
         // as on request cancellation error is returned
@@ -2165,7 +2203,7 @@ const createHttpTransport = (endpoint) => {
             throw error;
         }
         // unexpected error.
-        throw new Error((_c = response === null || response === void 0 ? void 0 : response.data) !== null && _c !== void 0 ? _c : error);
+        throw new Error((_d = response === null || response === void 0 ? void 0 : response.data) !== null && _d !== void 0 ? _d : error);
     });
     instance.defaults.paramsSerializer = {
         encode: params => encodeURIComponent(params),
@@ -2363,8 +2401,6 @@ const getItem = async (key) => {
     });
 };
 
-const uuid = () => uuid__default["default"].v4().toString();
-
 // TODO: find a way to uniquely identify the device
 let tabIndex = 0;
 // This logic is running on browser only
@@ -2424,22 +2460,60 @@ const getMQTTClientId = async (userId) => {
 };
 /** @hidden */
 const getDeviceModel = () => {
-    var _a, _b;
+    var _a;
     if ((_a = safeProcess.versions) === null || _a === void 0 ? void 0 : _a.node)
         return safeProcess.versions.node;
-    if (navigator)
-        return `${navigator.product.toLowerCase()}#${(_b = navigator.userAgent) !== null && _b !== void 0 ? _b : 'unknown_agent'}`;
-    return 'unknown_model';
+    return undefined;
+};
+const hasNavigator = () => typeof navigator !== 'undefined' && !!navigator;
+const getLocale = () => (hasNavigator() ? navigator.language : undefined);
+const getTimezone = () => {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    catch (_a) {
+        return undefined;
+    }
+};
+const getNetworkType = () => {
+    var _a;
+    if (!hasNavigator())
+        return undefined;
+    return (_a = navigator.connection) === null || _a === void 0 ? void 0 : _a.effectiveType;
+};
+const isNode = () => { var _a; return !!((_a = safeProcess.versions) === null || _a === void 0 ? void 0 : _a.node); };
+const parseUserAgent = () => {
+    if (!hasNavigator() || !navigator.userAgent)
+        return {};
+    const { os, browser, device } = new uaParserJs.UAParser(navigator.userAgent).getResult();
+    const result = {};
+    if (os.name)
+        result.osName = os.name;
+    if (os.version)
+        result.osVersion = os.version;
+    if (browser.name)
+        result.browserName = browser.name;
+    if (browser.version)
+        result.browserVersion = browser.version;
+    if (device.type === 'tablet')
+        result.deviceType = 'tablet';
+    else if (device.type === 'mobile')
+        result.deviceType = 'mobile';
+    else
+        result.deviceType = 'desktop';
+    return result;
 };
 /** @hidden */
 const getDeviceInfo = () => {
-    const model = getDeviceModel();
-    return {
-        // TODO: replace with: kind: process.versions ? 'node' : 'web', when backend has fixed this
-        kind: 'web',
-        model,
-        sdkVersion: VERSION,
-    };
+    var _a;
+    let client;
+    try {
+        client = getActiveClient();
+    }
+    catch (_b) {
+        client = undefined;
+    }
+    return Object.assign({ kind: isNode() ? 'node' : 'web', model: getDeviceModel(), sdkVersion: VERSION, product: (_a = client === null || client === void 0 ? void 0 : client.product) !== null && _a !== void 0 ? _a : 'sdk', uikitVersion: client === null || client === void 0 ? void 0 : client.uikitVersion, appId: client === null || client === void 0 ? void 0 : client.appId, appVersion: client === null || client === void 0 ? void 0 : client.appVersion, locale: getLocale(), timezone: getTimezone(), networkType: getNetworkType() }, parseUserAgent());
 };
 
 /* eslint-disable no-console */
@@ -3848,6 +3922,95 @@ const prepareChannelPayload = async (rawPayload, options = { isMessagePreviewUpd
         channelUsers });
 };
 
+const channelCacheKey = (channel) => [
+    'channel',
+    'get',
+    getResolver('channel')(channel),
+];
+/**
+ * Find a cached channel by any of its ids (internal, public, or `channelId`).
+ *
+ * The channel cache is keyed by the channel internal id (see `idResolvers.channel`), but
+ * realtime payloads reference channels by different ids: pin events carry the **public**
+ * id, messages carry `channelId`. Try the cheap direct lookup first, then scan.
+ */
+const findCachedChannelByAnyId = (id) => {
+    var _a, _b, _c;
+    if (!id)
+        return undefined;
+    const direct = (_a = pullFromCache(['channel', 'get', id])) === null || _a === void 0 ? void 0 : _a.data;
+    if (direct)
+        return direct;
+    return (_c = (_b = queryCache(['channel', 'get'])) === null || _b === void 0 ? void 0 : _b.find(({ data }) => data.channelInternalId === id || data.channelPublicId === id || data.channelId === id)) === null || _c === void 0 ? void 0 : _c.data;
+};
+/**
+ * Resolve the cached channel a `channel.messagePinned` / `channel.messageUnpinned` event
+ * refers to. `data.channelId` is the channel public id; a pinned message body (present on
+ * `messagePinned` only) also carries the internal id, which is the direct cache key.
+ */
+const findCachedChannelForPin = (payload) => {
+    var _a, _b;
+    return (_b = findCachedChannelByAnyId((_a = payload.pinnedMessage) === null || _a === void 0 ? void 0 : _a.channelId)) !== null && _b !== void 0 ? _b : findCachedChannelByAnyId(payload.channelId);
+};
+/**
+ * Write a new pin snapshot (or `null` to clear) on a cached channel and ingest any
+ * users delivered with it (the pin author and the message author), so the banner can
+ * render a byline without a second fetch.
+ *
+ * Every `messagePinned` payload is a full snapshot — "this is the pin now" — so the last
+ * one received always wins; there is no merging with the previous pin.
+ */
+const updatePinnedMessageCache = (channel, pinnedMessage, users) => {
+    if (users && users.length > 0) {
+        ingestInCache({ users: users.map(convertRawUserToInternalUser) });
+    }
+    const updated = Object.assign(Object.assign({}, channel), { pinnedMessage });
+    pushToCache(channelCacheKey(channel), updated);
+    return updated;
+};
+
+/**
+ * Applies a `channel.roleAdded` / `channel.roleRemoved` realtime payload to the cache.
+ *
+ * The event names every member the role request affected together with the
+ * roles and channel-scoped permissions each of them is left holding. That is a
+ * full state, not a delta, so it is written straight over the cached membership.
+ *
+ * Members the SDK has not fetched yet are skipped: the payload does not carry
+ * enough to build a full {@link Amity.Membership} and the live collections only
+ * emit rows that already exist in cache.
+ *
+ * @param payload the `data` of the realtime event
+ * @returns the refreshed channel (when resolvable) and the updated cached memberships
+ *
+ * @hidden
+ */
+const applyChannelRolePayload = (payload) => {
+    var _a, _b, _c;
+    const { channelId, users = [], channels = [] } = payload;
+    const rawChannel = (_a = channels.find(channel => channel.channelId === channelId)) !== null && _a !== void 0 ? _a : channels[0];
+    let channel;
+    if (rawChannel) {
+        const channelKey = ['channel', 'get', getResolver('channel')(rawChannel)];
+        // the role event does not touch message previews, keep whatever preview is cached
+        const converted = convertFromRaw(rawChannel, { isMessagePreviewUpdated: false });
+        upsertInCache(channelKey, converted);
+        channel = (_c = (_b = pullFromCache(channelKey)) === null || _b === void 0 ? void 0 : _b.data) !== null && _c !== void 0 ? _c : converted;
+    }
+    const members = [];
+    users.forEach(({ userId, roles, permissions }) => {
+        var _a, _b, _c;
+        const memberKey = ['channelUsers', 'get', getResolver('channelUsers')({ channelId, userId })];
+        const cached = (_a = pullFromCache(memberKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!cached)
+            return;
+        const updated = Object.assign(Object.assign({}, cached), { roles, permissions });
+        pushToCache(memberKey, updated);
+        members.push((_c = (_b = pullFromCache(memberKey)) === null || _b === void 0 ? void 0 : _b.data) !== null && _c !== void 0 ? _c : updated);
+    });
+    return { channel, members };
+};
+
 /**
  * ```js
  * import { getSubChannelMarkers } from '@amityco/ts-sdk'
@@ -4033,32 +4196,6 @@ const channelMemberLinkedObject = (channelMember) => {
         } });
 };
 
-/**
- *
- * get current user's membership data
- *
- * @returns the {@link Amity.Membership<'channel'>} objects
- *
- * @category Channel API
- * @async
- */
-const getMyMembership$1 = (channelId) => {
-    const client = getActiveClient();
-    client.log('channel/getMyMembership.locally');
-    const cacheChannelUser = pullFromCache([
-        'channelUsers',
-        'get',
-        `${channelId}#${client.userId}`,
-    ]);
-    if (!cacheChannelUser) {
-        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
-    }
-    return {
-        data: cacheChannelUser.data,
-        cachedAt: cacheChannelUser.cachedAt,
-    };
-};
-
 /**
  * ```js
  * import { isEqual } from '~/utils/isEqual'
@@ -4129,55 +4266,81 @@ function isEqual(x, y) {
         }));
 }
 
-const callbacks$c = [];
+/**
+ *
+ * get current user's membership data
+ *
+ * @returns the {@link Amity.Membership<'channel'>} objects
+ *
+ * @category Channel API
+ * @async
+ */
+const getMyMembership$1 = (channelId) => {
+    const client = getActiveClient();
+    client.log('channel/getMyMembership.locally');
+    const cacheChannelUser = pullFromCache([
+        'channelUsers',
+        'get',
+        `${channelId}#${client.userId}`,
+    ]);
+    if (!cacheChannelUser) {
+        throw new ASCApiError('Item not found!', 400400 /* Amity.ServerError.ITEM_NOT_FOUND */, "error" /* Amity.ErrorLevel.ERROR */);
+    }
+    return {
+        data: cacheChannelUser.data,
+        cachedAt: cacheChannelUser.cachedAt,
+    };
+};
+
+const callbacks$e = [];
 let mainDisposer$b = null;
-const dispose$c = (cb) => {
-    const index = callbacks$c.indexOf(cb);
+const dispose$e = (cb) => {
+    const index = callbacks$e.indexOf(cb);
     if (index > -1) {
-        callbacks$c.splice(index, 1);
+        callbacks$e.splice(index, 1);
     }
-    if (callbacks$c.length === 0) {
+    if (callbacks$e.length === 0) {
         mainDisposer$b === null || mainDisposer$b === void 0 ? void 0 : mainDisposer$b();
     }
 };
 const onChannelCreated = (callback) => {
-    if (callbacks$c.length === 0) {
+    if (callbacks$e.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
             ingestInCache(data);
-            callbacks$c.forEach(cb => cb(data.channels[0]));
+            callbacks$e.forEach(cb => cb(data.channels[0]));
         };
         mainDisposer$b = createEventSubscriber(client, 'onChannelCreated', 'channel.created', filter);
     }
-    callbacks$c.push(callback);
-    return () => dispose$c(callback);
+    callbacks$e.push(callback);
+    return () => dispose$e(callback);
 };
 
-const callbacks$b = [];
-const mainDisposers = [];
-const dispose$b = (cb) => {
-    const index = callbacks$b.indexOf(cb);
+const callbacks$d = [];
+const mainDisposers$2 = [];
+const dispose$d = (cb) => {
+    const index = callbacks$d.indexOf(cb);
     if (index > -1) {
-        callbacks$b.splice(index, 1);
+        callbacks$d.splice(index, 1);
     }
-    if (callbacks$b.length === 0) {
-        mainDisposers.forEach(fn => fn());
+    if (callbacks$d.length === 0) {
+        mainDisposers$2.forEach(fn => fn());
     }
 };
 const onChannelUpdated = (callback) => {
     const client = getActiveClient();
-    if (callbacks$b.length === 0) {
+    if (callbacks$d.length === 0) {
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
             ingestInCache(data);
-            callbacks$b.forEach(cb => cb(data.channels[0]));
+            callbacks$d.forEach(cb => cb(data.channels[0]));
         };
-        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter));
-        mainDisposers.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$b.forEach(cb => cb(payload.channels[0]))));
+        mainDisposers$2.push(createEventSubscriber(client, 'onChannelUpdated', 'channel.updated', filter));
+        mainDisposers$2.push(createEventSubscriber(client, 'onChannelUpdated', 'local.channel.updated', payload => callbacks$d.forEach(cb => cb(payload.channels[0]))));
     }
-    callbacks$b.push(callback);
-    return () => dispose$b(callback);
+    callbacks$d.push(callback);
+    return () => dispose$d(callback);
 };
 
 const addFlagIsDeletedSubChannelUnreadByChannelId = (channelId) => {
@@ -4200,19 +4363,19 @@ const deleteChannelUnreadByChannelId = (channelId) => {
     }
 };
 
-const callbacks$a = [];
+const callbacks$c = [];
 let mainDisposer$a = null;
-const dispose$a = (cb) => {
-    const index = callbacks$a.indexOf(cb);
+const dispose$c = (cb) => {
+    const index = callbacks$c.indexOf(cb);
     if (index > -1) {
-        callbacks$a.splice(index, 1);
+        callbacks$c.splice(index, 1);
     }
-    if (callbacks$a.length === 0) {
+    if (callbacks$c.length === 0) {
         mainDisposer$a === null || mainDisposer$a === void 0 ? void 0 : mainDisposer$a();
     }
 };
 const onChannelDeleted = (callback) => {
-    if (callbacks$a.length === 0) {
+    if (callbacks$c.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const data = await prepareChannelPayload(payload);
@@ -4232,53 +4395,53 @@ const onChannelDeleted = (callback) => {
                 }
             });
             ingestInCache(data);
-            callbacks$a.forEach(cb => cb(data.channels[0]));
+            callbacks$c.forEach(cb => cb(data.channels[0]));
         };
         mainDisposer$a = createEventSubscriber(client, 'onChannelDeleted', 'channel.deleted', filter);
     }
-    callbacks$a.push(callback);
-    return () => dispose$a(callback);
+    callbacks$c.push(callback);
+    return () => dispose$c(callback);
 };
 
-const callbacks$9 = [];
+const callbacks$b = [];
 let mainDisposer$9 = null;
-const dispose$9 = (cb) => {
-    const index = callbacks$9.indexOf(cb);
+const dispose$b = (cb) => {
+    const index = callbacks$b.indexOf(cb);
     if (index > -1) {
-        callbacks$9.splice(index, 1);
+        callbacks$b.splice(index, 1);
     }
-    if (callbacks$9.length === 0) {
+    if (callbacks$b.length === 0) {
         mainDisposer$9 === null || mainDisposer$9 === void 0 ? void 0 : mainDisposer$9();
     }
 };
 const onChannelJoined = (callback) => {
-    if (callbacks$9.length === 0) {
+    if (callbacks$b.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const preparedPayload = await prepareChannelPayload(payload);
             const { channels, channelUsers } = preparedPayload;
             ingestInCache(preparedPayload);
-            callbacks$9.forEach(cb => cb(channels[0], channelUsers[0]));
+            callbacks$b.forEach(cb => cb(channels[0], channelUsers[0]));
         };
         mainDisposer$9 = createEventSubscriber(client, 'onChannelJoined', 'channel.joined', filter);
     }
-    callbacks$9.push(callback);
-    return () => dispose$9(callback);
+    callbacks$b.push(callback);
+    return () => dispose$b(callback);
 };
 
-const callbacks$8 = [];
+const callbacks$a = [];
 let mainDisposer$8 = null;
-const dispose$8 = (cb) => {
-    const index = callbacks$8.indexOf(cb);
+const dispose$a = (cb) => {
+    const index = callbacks$a.indexOf(cb);
     if (index > -1) {
-        callbacks$8.splice(index, 1);
+        callbacks$a.splice(index, 1);
     }
-    if (callbacks$8.length === 0) {
+    if (callbacks$a.length === 0) {
         mainDisposer$8 === null || mainDisposer$8 === void 0 ? void 0 : mainDisposer$8();
     }
 };
 const onChannelLeft = (callback) => {
-    if (callbacks$8.length === 0) {
+    if (callbacks$a.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             const { userId } = getActiveClient();
@@ -4302,27 +4465,27 @@ const onChannelLeft = (callback) => {
             }
             const { channels, channelUsers } = preparedPayload;
             ingestInCache(preparedPayload);
-            callbacks$8.forEach(cb => cb(channels[0], channelUsers[0]));
+            callbacks$a.forEach(cb => cb(channels[0], channelUsers[0]));
         };
         mainDisposer$8 = createEventSubscriber(client, 'onChannelLeft', 'channel.left', filter);
     }
-    callbacks$8.push(callback);
-    return () => dispose$8(callback);
+    callbacks$a.push(callback);
+    return () => dispose$a(callback);
 };
 
-const callbacks$7 = [];
+const callbacks$9 = [];
 let mainDisposer$7 = null;
-const dispose$7 = (cb) => {
-    const index = callbacks$7.indexOf(cb);
+const dispose$9 = (cb) => {
+    const index = callbacks$9.indexOf(cb);
     if (index > -1) {
-        callbacks$7.splice(index, 1);
+        callbacks$9.splice(index, 1);
     }
-    if (callbacks$7.length === 0) {
+    if (callbacks$9.length === 0) {
         mainDisposer$7 === null || mainDisposer$7 === void 0 ? void 0 : mainDisposer$7();
     }
 };
 const onChannelSetMuted = (callback) => {
-    if (callbacks$7.length === 0) {
+    if (callbacks$9.length === 0) {
         const client = getActiveClient();
         const filter = async (payload) => {
             var _a;
@@ -4337,24 +4500,124 @@ const onChannelSetMuted = (callback) => {
                 payload.channelId,
             ])) === null || _a === void 0 ? void 0 : _a.data;
             if (channel) {
-                callbacks$7.forEach(cb => cb(channel));
+                callbacks$9.forEach(cb => cb(channel));
             }
         };
         mainDisposer$7 = createEventSubscriber(client, 'onChannelMute', 'channel.setMuted', filter);
     }
+    callbacks$9.push(callback);
+    return () => dispose$9(callback);
+};
+
+const callbacks$8 = [];
+let mainDisposer$6 = null;
+const dispose$8 = (cb) => {
+    const index = callbacks$8.indexOf(cb);
+    if (index > -1) {
+        callbacks$8.splice(index, 1);
+    }
+    if (callbacks$8.length === 0) {
+        mainDisposer$6 === null || mainDisposer$6 === void 0 ? void 0 : mainDisposer$6();
+    }
+};
+/* begin_public_function
+  id: channel.event.message_pinned
+*/
+/**
+ * ```js
+ * import { onChannelMessagePinned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMessagePinned(channel => {
+ *   // channel.pinnedMessage is the new pin
+ * })
+ * ```
+ *
+ * Fired when a message is pinned in a channel (the `channel.messagePinned` realtime
+ * event). Pinning a different message while one is already pinned emits a single
+ * `messagePinned` carrying the replacement — treat every payload as a full snapshot.
+ *
+ * The updated channel is written to cache before the callback runs, so
+ * `ChannelRepository.getChannel` observers see `channel.pinnedMessage` change.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to run when willing to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMessagePinned = (callback) => {
+    if (callbacks$8.length === 0) {
+        const client = getActiveClient();
+        const filter = (payload) => {
+            var _a;
+            const channel = findCachedChannelForPin(payload);
+            if (!channel)
+                return;
+            const updated = updatePinnedMessageCache(channel, (_a = payload.pinnedMessage) !== null && _a !== void 0 ? _a : null, payload.users);
+            callbacks$8.forEach(cb => cb(updated));
+        };
+        mainDisposer$6 = createEventSubscriber(client, 'onChannelMessagePinned', 'channel.messagePinned', filter);
+    }
+    callbacks$8.push(callback);
+    return () => dispose$8(callback);
+};
+/* end_public_function */
+
+const callbacks$7 = [];
+let mainDisposer$5 = null;
+const dispose$7 = (cb) => {
+    const index = callbacks$7.indexOf(cb);
+    if (index > -1) {
+        callbacks$7.splice(index, 1);
+    }
+    if (callbacks$7.length === 0) {
+        mainDisposer$5 === null || mainDisposer$5 === void 0 ? void 0 : mainDisposer$5();
+    }
+};
+/* begin_public_function
+  id: channel.event.message_unpinned
+*/
+/**
+ * ```js
+ * import { onChannelMessageUnpinned } from '@amityco/ts-sdk'
+ * const dispose = onChannelMessageUnpinned(channel => {
+ *   // channel.pinnedMessage is now null
+ * })
+ * ```
+ *
+ * Fired when a channel's pinned message is removed (the `channel.messageUnpinned`
+ * realtime event) — either by an explicit unpin or automatically by the server when the
+ * pinned message is deleted or its author is banned from the channel / globally.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to run when willing to stop listening
+ *
+ * @category Channel Events
+ */
+const onChannelMessageUnpinned = (callback) => {
+    if (callbacks$7.length === 0) {
+        const client = getActiveClient();
+        const filter = (payload) => {
+            const channel = findCachedChannelForPin(payload);
+            if (!channel)
+                return;
+            const updated = updatePinnedMessageCache(channel, null);
+            callbacks$7.forEach(cb => cb(updated));
+        };
+        mainDisposer$5 = createEventSubscriber(client, 'onChannelMessageUnpinned', 'channel.messageUnpinned', filter);
+    }
     callbacks$7.push(callback);
     return () => dispose$7(callback);
 };
+/* end_public_function */
 
 const callbacks$6 = [];
-let mainDisposer$6 = null;
+let mainDisposer$4 = null;
 const dispose$6 = (cb) => {
     const index = callbacks$6.indexOf(cb);
     if (index > -1) {
         callbacks$6.splice(index, 1);
     }
     if (callbacks$6.length === 0) {
-        mainDisposer$6 === null || mainDisposer$6 === void 0 ? void 0 : mainDisposer$6();
+        mainDisposer$4 === null || mainDisposer$4 === void 0 ? void 0 : mainDisposer$4();
     }
 };
 const onChannelMemberAdded = (callback) => {
@@ -4366,21 +4629,21 @@ const onChannelMemberAdded = (callback) => {
             ingestInCache(preparedPayload);
             callbacks$6.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'member')));
         };
-        mainDisposer$6 = createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
+        mainDisposer$4 = createEventSubscriber(client, 'onChannelMemberAdded', 'channel.membersAdded', filter);
     }
     callbacks$6.push(callback);
     return () => dispose$6(callback);
 };
 
 const callbacks$5 = [];
-let mainDisposer$5 = null;
+let mainDisposer$3 = null;
 const dispose$5 = (cb) => {
     const index = callbacks$5.indexOf(cb);
     if (index > -1) {
         callbacks$5.splice(index, 1);
     }
     if (callbacks$5.length === 0) {
-        mainDisposer$5 === null || mainDisposer$5 === void 0 ? void 0 : mainDisposer$5();
+        mainDisposer$3 === null || mainDisposer$3 === void 0 ? void 0 : mainDisposer$3();
     }
 };
 const onChannelMemberRemoved = (callback) => {
@@ -4392,21 +4655,21 @@ const onChannelMemberRemoved = (callback) => {
             ingestInCache(preparedPayload);
             callbacks$5.forEach(cb => cb(channels[0], channelUsers[0]));
         };
-        mainDisposer$5 = createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
+        mainDisposer$3 = createEventSubscriber(client, 'onChannelMemberRemoved', 'channel.membersRemoved', filter);
     }
     callbacks$5.push(callback);
     return () => dispose$5(callback);
 };
 
 const callbacks$4 = [];
-let mainDisposer$4 = null;
+let mainDisposer$2 = null;
 const dispose$4 = (cb) => {
     const index = callbacks$4.indexOf(cb);
     if (index > -1) {
         callbacks$4.splice(index, 1);
     }
     if (callbacks$4.length === 0) {
-        mainDisposer$4 === null || mainDisposer$4 === void 0 ? void 0 : mainDisposer$4();
+        mainDisposer$2 === null || mainDisposer$2 === void 0 ? void 0 : mainDisposer$2();
     }
 };
 const onChannelMemberBanned = (callback) => {
@@ -4426,20 +4689,20 @@ const onChannelMemberBanned = (callback) => {
         ingestInCache(preparedPayload);
         callbacks$4.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'banned')));
     };
-    mainDisposer$4 = createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
+    mainDisposer$2 = createEventSubscriber(client, 'onChannelMemberBanned', 'channel.banned', filter);
     callbacks$4.push(callback);
     return () => dispose$4(callback);
 };
 
 const callbacks$3 = [];
-let mainDisposer$3 = null;
+let mainDisposer$1 = null;
 const dispose$3 = (cb) => {
     const index = callbacks$3.indexOf(cb);
     if (index > -1) {
         callbacks$3.splice(index, 1);
     }
     if (callbacks$3.length === 0) {
-        mainDisposer$3 === null || mainDisposer$3 === void 0 ? void 0 : mainDisposer$3();
+        mainDisposer$1 === null || mainDisposer$1 === void 0 ? void 0 : mainDisposer$1();
     }
 };
 const onChannelMemberUnbanned = (callback) => {
@@ -4451,59 +4714,127 @@ const onChannelMemberUnbanned = (callback) => {
             ingestInCache(preparedPayload);
             callbacks$3.forEach(cb => cb(channels[0], channelUsers.find(cu => cu.membership === 'none')));
         };
-        mainDisposer$3 = createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
+        mainDisposer$1 = createEventSubscriber(client, 'onChannelMemberUnbanned', 'channel.unbanned', filter);
     }
     callbacks$3.push(callback);
     return () => dispose$3(callback);
 };
 
 const callbacks$2 = [];
-let mainDisposer$2 = null;
+const mainDisposers$1 = [];
 const dispose$2 = (cb) => {
     const index = callbacks$2.indexOf(cb);
     if (index > -1) {
         callbacks$2.splice(index, 1);
     }
     if (callbacks$2.length === 0) {
-        mainDisposer$2 === null || mainDisposer$2 === void 0 ? void 0 : mainDisposer$2();
+        mainDisposers$1.forEach(fn => fn());
+        mainDisposers$1.length = 0;
     }
 };
+/* begin_public_function
+  id: channel.event.member_role_added
+*/
+/**
+ * ```js
+ * import { onChannelMemberRoleAdded } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRoleAdded((channel, member) => {
+ *   // member.roles and member.permissions are the member's resulting state
+ * })
+ * ```
+ *
+ * Fired when a role is added to a member of a {@link Amity.Channel}, either by the
+ * local `ChannelRepository.Moderation.addRole` call or by the `channel.roleAdded` realtime
+ * event coming from any client or the admin console.
+ *
+ * The realtime event reaches every subscriber of the channel topic (see `getChannelTopic`),
+ * not only the actor or the affected members. It carries the affected members' resulting
+ * channel roles and channel-scoped permissions, which are written to cache before the
+ * callback runs. The callback is invoked once per affected member already held in cache.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to run when willing to stop listening
+ *
+ * @category Channel Events
+ */
 const onChannelMemberRoleAdded = (callback) => {
     if (callbacks$2.length === 0) {
         const client = getActiveClient();
-        const filter = async (payload) => {
+        const onLocal = async (payload) => {
             const { channels, channelUsers } = payload;
             callbacks$2.forEach(cb => cb(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')));
         };
-        mainDisposer$2 = createEventSubscriber(client, 'onChannelMemberRoleAdded', 'local.channel-moderator.role-added', filter);
+        const onRealtime = (payload) => {
+            const { channel, members } = applyChannelRolePayload(payload);
+            if (!channel)
+                return;
+            members.forEach(member => callbacks$2.forEach(cb => cb(channel, member)));
+        };
+        mainDisposers$1.push(createEventSubscriber(client, 'onChannelMemberRoleAdded', 'local.channel-moderator.role-added', onLocal));
+        mainDisposers$1.push(createEventSubscriber(client, 'onChannelMemberRoleAdded', 'channel.roleAdded', onRealtime));
     }
     callbacks$2.push(callback);
     return () => dispose$2(callback);
 };
+/* end_public_function */
 
 const callbacks$1 = [];
-let mainDisposer$1 = null;
+const mainDisposers = [];
 const dispose$1 = (cb) => {
     const index = callbacks$1.indexOf(cb);
     if (index > -1) {
         callbacks$1.splice(index, 1);
     }
     if (callbacks$1.length === 0) {
-        mainDisposer$1 === null || mainDisposer$1 === void 0 ? void 0 : mainDisposer$1();
+        mainDisposers.forEach(fn => fn());
+        mainDisposers.length = 0;
     }
 };
+/* begin_public_function
+  id: channel.event.member_role_removed
+*/
+/**
+ * ```js
+ * import { onChannelMemberRoleRemoved } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRoleRemoved((channel, member) => {
+ *   // member.roles and member.permissions are the member's resulting state
+ * })
+ * ```
+ *
+ * Fired when a role is removed from a member of a {@link Amity.Channel}, either by the
+ * local `ChannelRepository.Moderation.removeRole` call or by the `channel.roleRemoved` realtime
+ * event coming from any client or the admin console.
+ *
+ * The realtime event reaches every subscriber of the channel topic (see `getChannelTopic`),
+ * not only the actor or the affected members. It carries the affected members' resulting
+ * channel roles and channel-scoped permissions, which are written to cache before the
+ * callback runs. The callback is invoked once per affected member already held in cache.
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to run when willing to stop listening
+ *
+ * @category Channel Events
+ */
 const onChannelMemberRoleRemoved = (callback) => {
     if (callbacks$1.length === 0) {
         const client = getActiveClient();
-        const filter = async (payload) => {
+        const onLocal = async (payload) => {
             const { channels, channelUsers } = payload;
             callbacks$1.forEach(cb => cb(channels[0], channelUsers.find(channelUser => channelUser.membership === 'member')));
         };
-        mainDisposer$1 = createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'local.channel-moderator.role-removed', filter);
+        const onRealtime = (payload) => {
+            const { channel, members } = applyChannelRolePayload(payload);
+            if (!channel)
+                return;
+            members.forEach(member => callbacks$1.forEach(cb => cb(channel, member)));
+        };
+        mainDisposers.push(createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'local.channel-moderator.role-removed', onLocal));
+        mainDisposers.push(createEventSubscriber(client, 'onChannelMemberRoleRemoved', 'channel.roleRemoved', onRealtime));
     }
     callbacks$1.push(callback);
     return () => dispose$1(callback);
 };
+/* end_public_function */
 
 /**
  * Fired when a {@link Amity.Channel} has been archived by the active user.
@@ -4627,6 +4958,8 @@ const getMyMembership = (channelId, callback) => {
     disposers.push(onChannelMemberBanned(realtimeRouter));
     disposers.push(onChannelMemberUnbanned(realtimeRouter));
     disposers.push(onChannelSetUserMuted(realtimeRouter));
+    disposers.push(onChannelMemberRoleAdded(realtimeRouter));
+    disposers.push(onChannelMemberRoleRemoved(realtimeRouter));
     onFetch();
     return () => {
         disposers.forEach(fn => fn());
@@ -5020,7 +5353,9 @@ const initializeMessagePreviewSetting = async () => {
 const getSocialSettings = async () => {
     const client = getActiveClient();
     const { data } = await client.http.get(`/api/v3/network-settings/social`);
-    return data.socialNetworkSetting;
+    return Object.assign(Object.assign({}, data.socialNetworkSetting), { 
+        // Networks that never set the comment edit switch allow the edit
+        isAllowEditCommentWhenReviewingEnabled: data.socialNetworkSetting.isAllowEditCommentWhenReviewingEnabled });
 };
 
 /**
@@ -5706,6 +6041,32 @@ class AnalyticsEventCapturer {
             activityType: "view" /* Amity.AnalyticEventActivityType.View */,
         });
     }
+    markCuratedContentWidgetAsViewed(topicId) {
+        this.markAs({
+            uniqueId: `curatedContentWidget.${topicId}`,
+            contentId: topicId,
+            contentType: "curated_content_widget" /* Amity.AnalyticEventContentType.CuratedContentWidget */,
+            activityType: "view" /* Amity.AnalyticEventActivityType.View */,
+        });
+    }
+    markCuratedContentPostAsViewed(postId, topicId) {
+        this.markAs({
+            uniqueId: `curatedContentPost.${postId}.view`,
+            contentId: postId,
+            contentType: "curated_content_post" /* Amity.AnalyticEventContentType.CuratedContentPost */,
+            activityType: "view" /* Amity.AnalyticEventActivityType.View */,
+            metadata: { topicId },
+        });
+    }
+    markCuratedContentPostAsClicked(postId, topicId) {
+        this.markAs({
+            uniqueId: `curatedContentPost.${postId}.click`,
+            contentId: postId,
+            contentType: "curated_content_post" /* Amity.AnalyticEventContentType.CuratedContentPost */,
+            activityType: "linkClicked" /* Amity.AnalyticEventActivityType.Click */,
+            metadata: { topicId },
+        });
+    }
     markPostAsMeaningfullyViewed(postId, feedRenderPosition) {
         var _a;
         const cached = (_a = pullFromCache(['feedMetadata', 'get', postId])) === null || _a === void 0 ? void 0 : _a.data;
@@ -5869,6 +6230,24 @@ class AnalyticsEngine {
             this._eventCapturer.markPostAsViewed(postId);
         }
     }
+    markCuratedContentWidgetAsViewed(topicId) {
+        if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
+            this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            this._eventCapturer.markCuratedContentWidgetAsViewed(topicId);
+        }
+    }
+    markCuratedContentPostAsViewed(postId, topicId) {
+        if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
+            this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            this._eventCapturer.markCuratedContentPostAsViewed(postId, topicId);
+        }
+    }
+    markCuratedContentPostAsClicked(postId, topicId) {
+        if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
+            this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
+            this._eventCapturer.markCuratedContentPostAsClicked(postId, topicId);
+        }
+    }
     markPostAsMeaningfullyViewed(postId, feedRenderPosition) {
         if (this._client.sessionState === "established" /* Amity.SessionStates.ESTABLISHED */ ||
             this._client.sessionState === "tokenExpired" /* Amity.SessionStates.TOKEN_EXPIRED */) {
@@ -7265,6 +7644,265 @@ class CursorController {
     }
 }
 
+class ResetTask {
+    constructor(postId, latestCreatedAt, serverCommentCount) {
+        this.postId = postId;
+        this.latestCreatedAt = latestCreatedAt;
+        this.serverCommentCount = serverCommentCount;
+    }
+}
+
+// Task to track comment creation
+class CreateTask {
+    constructor(postId, commentId, createdAt) {
+        this.postId = postId;
+        this.commentId = commentId;
+        this.createdAt = createdAt;
+    }
+}
+
+/**
+ * A pending comment was approved and now counts publicly. Unlike `CreateTask` it carries no
+ * `createdAt` and bypasses the age guard on purpose: the comment was written before the last post
+ * payload (so its `createdAt` is old) but entered the server count only now. Same rule as iOS.
+ *
+ * Accepted trade-off (plan 40 §9): if a `ResetTask` that already includes this comment lands
+ * between the approve response and the late `comment.approved` event, the count reads +1 until
+ * the next server sync — the same self-correcting drift accepted for stale deletes.
+ */
+class ApproveTask {
+    constructor(postId, commentId) {
+        this.postId = postId;
+        this.commentId = commentId;
+    }
+}
+
+// Task to track comment deletion
+class DeleteTask {
+    constructor(postId, commentId) {
+        this.postId = postId;
+        this.commentId = commentId;
+    }
+}
+
+class CommentChange {
+    constructor(latestCreatedAt, serverCommentCount) {
+        this.latestCommentCreatedAt = latestCreatedAt;
+        this.serverCommentCount = serverCommentCount;
+        this.createdCommentIds = new Set();
+        this.deletedCommentIds = new Set();
+    }
+}
+
+class PostCommentCountEngine {
+    constructor() {
+        this.isProcessing = false;
+        this.tasks = [];
+        this.commentChangeTracker = new Map();
+        // Ids of the LOGGED-IN USER's own pending comments, per post. Survives ResetTask, so the
+        // author's +1 does not vanish on the next post refresh; emptied only when the comment leaves
+        // the pending state (approval hands it to createdCommentIds, decline/delete drops it).
+        this.pendingAuthoredCommentIds = new Map();
+    }
+    queueCommentChangeTask(task) {
+        this.tasks.push(task);
+        if (!this.isProcessing) {
+            this.processCommentChangeTask();
+        }
+    }
+    addPendingAuthoredComment(postId, commentId, { publish = true } = {}) {
+        var _a;
+        const ids = (_a = this.pendingAuthoredCommentIds.get(postId)) !== null && _a !== void 0 ? _a : new Set();
+        if (ids.has(commentId))
+            return;
+        ids.add(commentId);
+        this.pendingAuthoredCommentIds.set(postId, ids);
+        if (publish)
+            this.publishIfTracked(postId);
+    }
+    removePendingAuthoredComment(postId, commentId, { publish = true } = {}) {
+        const ids = this.pendingAuthoredCommentIds.get(postId);
+        if (!(ids === null || ids === void 0 ? void 0 : ids.delete(commentId)))
+            return false;
+        if (ids.size === 0)
+            this.pendingAuthoredCommentIds.delete(postId);
+        if (publish)
+            this.publishIfTracked(postId);
+        return true;
+    }
+    /** Whether a post payload has seeded this post; without one every count is `0`. */
+    hasTracker(postId) {
+        return this.commentChangeTracker.has(postId);
+    }
+    isPendingAuthoredComment(postId, commentId) {
+        var _a, _b;
+        return (_b = (_a = this.pendingAuthoredCommentIds.get(postId)) === null || _a === void 0 ? void 0 : _a.has(commentId)) !== null && _b !== void 0 ? _b : false;
+    }
+    // Drops every per-post state. Called on logout / user switch.
+    reset() {
+        this.tasks = [];
+        this.commentChangeTracker.clear();
+        this.pendingAuthoredCommentIds.clear();
+    }
+    publishIfTracked(postId) {
+        // Without a tracker there is no server figure to add to; the next ResetTask picks it up.
+        if (!this.commentChangeTracker.has(postId))
+            return;
+        PostCommentCountEngine.publishUpdate(postId, this.getLocalCommentCount(postId, true));
+    }
+    processCommentChangeTask() {
+        if (this.isProcessing) {
+            return;
+        }
+        this.isProcessing = true;
+        if (this.tasks.length === 0) {
+            this.isProcessing = false;
+            return;
+        }
+        // Process in capped batches, coalescing updates
+        const batch = this.tasks.splice(0, PostCommentCountEngine.BATCH_SIZE);
+        const modifiedPostIds = new Set();
+        batch.forEach(task => {
+            let modified = false;
+            if (task instanceof ResetTask) {
+                modified = this.processResetTaskInternal(task);
+            }
+            else if (task instanceof CreateTask) {
+                modified = this.processCreateTaskInternal(task);
+            }
+            else if (task instanceof ApproveTask) {
+                modified = this.processApproveTaskInternal(task);
+            }
+            else if (task instanceof DeleteTask) {
+                modified = this.processDeleteTaskInternal(task);
+            }
+            if (modified) {
+                modifiedPostIds.add(task.postId);
+            }
+        });
+        // Publish one update per modified post
+        modifiedPostIds.forEach(postId => {
+            PostCommentCountEngine.publishUpdate(postId, this.getLocalCommentCount(postId, true));
+        });
+        this.isProcessing = false;
+        // Recurse if more tasks remain
+        if (this.tasks.length > 0) {
+            this.processCommentChangeTask();
+        }
+    }
+    processResetTaskInternal(task) {
+        // Always creates/overwrites tracker
+        this.commentChangeTracker.set(task.postId, new CommentChange(task.latestCreatedAt, task.serverCommentCount));
+        return true;
+    }
+    processCreateTaskInternal(task) {
+        // The comment is public now: the author-local +1 hands over to the normal path, so the
+        // count stays put instead of moving twice.
+        const wasPendingAuthored = this.removePendingAuthoredComment(task.postId, task.commentId, {
+            publish: false,
+        });
+        const tracker = this.commentChangeTracker.get(task.postId);
+        if (!tracker)
+            return false; // No tracker, skip
+        if (tracker.deletedCommentIds.delete(task.commentId))
+            return true; // Re-approval cancels the earlier removal
+        if (tracker.createdCommentIds.has(task.commentId))
+            return wasPendingAuthored; // Deduplication
+        if (task.createdAt <= tracker.latestCommentCreatedAt)
+            return wasPendingAuthored; // Timestamp filtering
+        tracker.createdCommentIds.add(task.commentId);
+        return true;
+    }
+    processApproveTaskInternal(task) {
+        // The comment is public now: the author-local +1 hands over to the normal path, so the
+        // count stays put instead of moving twice.
+        const wasPendingAuthored = this.removePendingAuthoredComment(task.postId, task.commentId, {
+            publish: false,
+        });
+        const tracker = this.commentChangeTracker.get(task.postId);
+        if (!tracker)
+            return false; // No tracker, skip
+        if (tracker.deletedCommentIds.delete(task.commentId))
+            return true; // Re-approval cancels the earlier re-review removal
+        if (tracker.createdCommentIds.has(task.commentId))
+            return wasPendingAuthored; // Approve response and comment.approved event dedupe by id
+        // No timestamp filtering: approval is the moment the comment enters the count, not createdAt
+        tracker.createdCommentIds.add(task.commentId);
+        return true;
+    }
+    processDeleteTaskInternal(task) {
+        const tracker = this.commentChangeTracker.get(task.postId);
+        if (!tracker)
+            return false; // No tracker, skip
+        if (tracker.deletedCommentIds.has(task.commentId))
+            return false; // Deduplication
+        tracker.deletedCommentIds.add(task.commentId);
+        return true;
+    }
+    /**
+     * The count as this session sees it: the last server figure plus the local delta.
+     *
+     * `includePending` adds the logged-in user's own pending comments — the author's view. A
+     * pending id is added only while the public delta does not already count it, so a comment
+     * present in both sets counts once: a `comment.created` that arrives pending after the
+     * `comment.approved` hand-over adds nothing, while an approved comment sent back to review
+     * (created, deleted and pending all hold its id) keeps the author's +1.
+     *
+     * `0` for a post no payload has seeded yet; callers fall back to the post's own figure.
+     */
+    getLocalCommentCount(postId, includePending = false) {
+        var _a;
+        const tracker = this.commentChangeTracker.get(postId);
+        if (!tracker)
+            return 0;
+        const publicDelta = tracker.createdCommentIds.size - tracker.deletedCommentIds.size;
+        if (!includePending)
+            return Math.max(0, tracker.serverCommentCount + publicDelta);
+        let pendingExtra = 0;
+        (_a = this.pendingAuthoredCommentIds.get(postId)) === null || _a === void 0 ? void 0 : _a.forEach(commentId => {
+            const countedPublicly = tracker.createdCommentIds.has(commentId) && !tracker.deletedCommentIds.has(commentId);
+            if (!countedPublicly)
+                pendingExtra += 1;
+        });
+        return Math.max(0, tracker.serverCommentCount + publicDelta + pendingExtra);
+    }
+    static publishUpdate(postId, newCount) {
+        var _a;
+        const queryKey = ['post', 'get', postId];
+        mergeInCache(queryKey, {
+            localCommentCount: newCount,
+        });
+        const postPayload = (_a = pullFromCache(queryKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!postPayload)
+            return;
+        fireEvent('local.post.updated', {
+            posts: [postPayload],
+        });
+    }
+}
+PostCommentCountEngine.BATCH_SIZE = 50;
+let instance$1;
+var PostCommentCountEngine$1 = {
+    getInstance: () => {
+        if (!instance$1) {
+            instance$1 = new PostCommentCountEngine();
+        }
+        return instance$1;
+    },
+};
+
+/**
+ * Comment-count state is per user — in particular the ids of the logged-in user's own pending
+ * comments — so it must not survive a logout or a user switch.
+ *
+ * @category private
+ */
+const postCommentCountEngineOnLoginHandler = () => onSessionStateChange(state => {
+    if (state === "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */ || state === "terminated" /* Amity.SessionStates.TERMINATED */) {
+        PostCommentCountEngine$1.getInstance().reset();
+    }
+});
+
 const EVENTS = [
     'disconnected',
     'error',
@@ -7454,7 +8092,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(), blockingUserSyncEngineOnLoginHandler(), blockRealtimeOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout());
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), blockingUserSyncEngineOnLoginHandler(), blockRealtimeOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout(), postCommentCountEngineOnLoginHandler());
     if (client.useLegacyUnreadCount) {
         subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
@@ -8490,7 +9128,7 @@ const DEFAULT_DEBUG_SESSION = 'amity';
  *
  * @category Client API
  * */
-const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAULT_DEBUG_SESSION, apiEndpoint, prefixDeviceIdKey, rteEnabled = true, } = {}) => {
+const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAULT_DEBUG_SESSION, apiEndpoint, prefixDeviceIdKey, rteEnabled = true, product, uikitVersion, appId, appVersion, } = {}) => {
     var _a, _b, _c;
     const log = createLogger(debugSession);
     log('client/api/createClient', {
@@ -8519,6 +9157,10 @@ const createClient = (apiKey, apiRegion = API_REGIONS.SG, { debugSession = DEFAU
     const useLegacyUnreadCount = true;
     const client = {
         version: `${VERSION}`,
+        product,
+        uikitVersion,
+        appId,
+        appVersion,
         apiKey,
         /*
          * SDK Components
@@ -8757,13 +9399,13 @@ class GlobalFileAccessType {
     }
 }
 _GlobalFileAccessType_fileAccessType = new WeakMap();
-let instance$1;
+let instance;
 var GlobalFileAccessType$1 = {
     getInstance: () => {
-        if (!instance$1) {
-            instance$1 = new GlobalFileAccessType();
+        if (!instance) {
+            instance = new GlobalFileAccessType();
         }
-        return instance$1;
+        return instance;
     },
 };
 
@@ -9600,7 +10242,7 @@ const getUserUnread = (callback) => {
     };
 };
 
-var index$s = /*#__PURE__*/Object.freeze({
+var index$t = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getActiveClient: getActiveClient,
     getActiveUser: getActiveUser,
@@ -10826,7 +11468,7 @@ const getMyFollowInfo = (callback) => {
 };
 /* end_public_function */
 
-var index$r = /*#__PURE__*/Object.freeze({
+var index$s = /*#__PURE__*/Object.freeze({
     __proto__: null,
     blockUser: blockUser,
     unBlockUser: unBlockUser,
@@ -12338,8 +12980,32 @@ const streamLinkedObject = (stream) => {
         } });
 };
 
+const KNOWN_APPROVAL_STATUSES = [
+    "pending" /* Amity.CommentApprovalStatusEnum.Pending */,
+    "approved" /* Amity.CommentApprovalStatusEnum.Approved */,
+    "rejected" /* Amity.CommentApprovalStatusEnum.Rejected */,
+];
+/**
+ * The server sends `approvalStatus` only while a comment is held for review or after it was
+ * rejected. Absent, `null`, or an unrecognised value all resolve to `approved` — never to
+ * `pending`, which would mark every comment written before the feature as unpublished.
+ */
+const resolveCommentApprovalStatus = (approvalStatus) => {
+    if (approvalStatus && KNOWN_APPROVAL_STATUSES.includes(approvalStatus)) {
+        return approvalStatus;
+    }
+    return "approved" /* Amity.CommentApprovalStatusEnum.Approved */;
+};
+const prepareComment = (comment) => (Object.assign(Object.assign(Object.assign({}, (comment.hasOwnProperty('myReactions') ? {} : { myReactions: [] })), comment), { approvalStatus: resolveCommentApprovalStatus(comment.approvalStatus) }));
+function prepareCommentPayload(commentPayload) {
+    const { comments, commentChildren } = commentPayload;
+    return Object.assign(Object.assign(Object.assign({}, commentPayload), { comments: comments.map(prepareComment) }), (commentChildren ? { commentChildren: commentChildren.map(prepareComment) } : {}));
+}
+
 const commentLinkedObject = (comment) => {
-    return Object.assign(Object.assign({}, comment), { get target() {
+    return Object.assign(Object.assign({}, comment), { 
+        // Non-optional on the public model: absent on the wire means approved
+        approvalStatus: resolveCommentApprovalStatus(comment.approvalStatus), get target() {
             const commentTypes = {
                 type: comment.targetType,
             };
@@ -12547,7 +13213,7 @@ const getWatchSessionStorage = () => {
     return storageInstance;
 };
 
-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-----";
+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=";
 /*
  * The crypto algorithm used for importing key and signing string
  */
@@ -12990,6 +13656,122 @@ const fileLinkedObject = (file) => {
     return file;
 };
 
+const isCommentPending = (comment) => resolveCommentApprovalStatus(comment.approvalStatus) === "pending" /* Amity.CommentApprovalStatusEnum.Pending */;
+const isCommentApproved = (comment) => resolveCommentApprovalStatus(comment.approvalStatus) === "approved" /* Amity.CommentApprovalStatusEnum.Approved */;
+// Only post and content references feed PostCommentCountEngine; story counts live on the story.
+const isCountedReference = (comment) => ['post', 'content'].includes(comment.referenceType);
+const isAuthoredByCurrentUser = (comment) => comment.userId === getActiveClient().userId;
+/**
+ * Whether a comment on this reference would be held for review, read from the cached post's
+ * community. `true` when that cannot be known — the post or its community is not cached yet.
+ * A pending guess that turns out approved is corrected by the response and the comment then
+ * enters the list; an approved guess that turns out pending has already been shown in a public
+ * list with nothing to take it back out. Only shapes the optimistic object — the server
+ * response is the authority on the actual status.
+ */
+const isCommentApprovalRequired = (bundle) => {
+    var _a, _b;
+    // Only comments on community posts are gated; every other reference is known-off
+    if (bundle.referenceType !== 'post')
+        return false;
+    const post = (_a = pullFromCache(['post', 'get', bundle.referenceId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (!post)
+        return true;
+    // A user-feed post is known-off
+    if (post.targetType !== 'community')
+        return false;
+    const community = (_b = pullFromCache([
+        'community',
+        'get',
+        post.targetId,
+    ])) === null || _b === void 0 ? void 0 : _b.data;
+    if (!community)
+        return true;
+    return community.needApprovalOnCommentCreation === true;
+};
+/**
+ * An approved comment arrived over realtime: one `CreateTask` carrying its own `createdAt`, so
+ * the timestamp filter skips anything the last post payload already counted. The author's own
+ * comment reaches here as an echo too; the engine de-duplicates it by id against the task the
+ * create response queued.
+ */
+const applyCommentCreatedCount = (comment) => {
+    if (!isCountedReference(comment))
+        return;
+    PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new CreateTask(comment.referenceId, comment.commentId, comment.createdAt));
+};
+/**
+ * The author's own pending comment counts in their view only. Recorded as separate engine state
+ * so it survives a post refresh (`ResetTask`).
+ */
+const recordPendingAuthoredComment = (comment, options) => {
+    if (!isCountedReference(comment) || !isAuthoredByCurrentUser(comment))
+        return;
+    PostCommentCountEngine$1.getInstance().addPendingAuthoredComment(comment.referenceId, comment.commentId, options);
+};
+/**
+ * A pending comment was declined or deleted: it was never in the server count, so no
+ * `DeleteTask` — only the author-local +1 goes away.
+ */
+const releasePendingAuthoredComment = (comment) => {
+    if (!isCountedReference(comment))
+        return;
+    PostCommentCountEngine$1.getInstance().removePendingAuthoredComment(comment.referenceId, comment.commentId);
+};
+/**
+ * Reveal: exactly one `ApproveTask`. The engine de-duplicates by comment id, so the approve
+ * response and the `comment.approved` event may both call this. `ApproveTask` bypasses the age
+ * guard on purpose — the comment was written before the last server sync but enters the public
+ * count now — matching the iOS `ApproveTask` (plan 40 §9, guard off for approve).
+ */
+const applyCommentApprovedCount = (comment) => {
+    if (!isCountedReference(comment))
+        return;
+    PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new ApproveTask(comment.referenceId, comment.commentId));
+};
+/**
+ * Re-review: an approved comment edited back to pending leaves the public count once. The
+ * author keeps their own +1 through the pending set, so their count does not move.
+ */
+const applyCommentReReviewCount = (comment) => {
+    if (!isCountedReference(comment))
+        return;
+    recordPendingAuthoredComment(comment, { publish: false });
+    PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new DeleteTask(comment.referenceId, comment.commentId));
+};
+/** Adds a reply to its cached parent's `children` (and count) once. */
+const linkCommentToParent = (comment) => {
+    var _a;
+    if (!comment.parentId)
+        return;
+    const parentKey = ['comment', 'get', comment.parentId];
+    const parent = (_a = pullFromCache(parentKey)) === null || _a === void 0 ? void 0 : _a.data;
+    if (!parent || parent.children.includes(comment.commentId))
+        return;
+    pushToCache(parentKey, Object.assign(Object.assign({}, parent), { childrenNumber: parent.childrenNumber + 1, children: [...new Set([...parent.children, comment.commentId])] }));
+};
+/** Removes a reply from its cached parent's `children` (and count) once. */
+const unlinkCommentFromParent = (comment) => {
+    var _a;
+    if (!comment.parentId)
+        return;
+    const parentKey = ['comment', 'get', comment.parentId];
+    const parent = (_a = pullFromCache(parentKey)) === null || _a === void 0 ? void 0 : _a.data;
+    if (!parent || !parent.children.includes(comment.commentId))
+        return;
+    pushToCache(parentKey, Object.assign(Object.assign({}, parent), { childrenNumber: parent.childrenNumber - 1, children: parent.children.filter(id => id !== comment.commentId) }));
+};
+
+/**
+ * The server's list is oldest → newest, so the newest ids are the last ones. Kept unique so the
+ * create response, the local event and the realtime echo cannot each add the same comment.
+ */
+const capLatestCommentIds = (commentIds) => [...new Set(commentIds)].slice(-LATEST_COMMENTS_LIMIT);
+/** A comment belongs in the post preview only while it is cached, not deleted and public. */
+const isPreviewableComment = (comment) => comment !== undefined && !comment.isDeleted && isCommentApproved(comment);
+/** The post's preview list after one of the user's own top-level comments is created. */
+const appendLatestCommentId = (post, commentId) => { var _a; return capLatestCommentIds([...((_a = post.comments) !== null && _a !== void 0 ? _a : []), commentId]); };
+
 const postLinkedObject = (post) => {
     return shallowClone(post, {
         childrenPosts: post.children
@@ -13013,19 +13795,13 @@ const postLinkedObject = (post) => {
         get latestComments() {
             if (!post.comments)
                 return [];
-            return (post.comments
-                .map(commentId => {
-                var _a;
-                const commentCached = (_a = pullFromCache([
-                    'comment',
-                    'get',
-                    commentId,
-                ])) === null || _a === void 0 ? void 0 : _a.data;
-                if (!commentCached)
-                    return null;
-                return commentLinkedObject(commentCached);
-            })
-                .filter(Boolean) || []);
+            // Same rule as the server's own list and as iOS: deleted and non-public comments are
+            // dropped first, then the newest LATEST_COMMENTS_LIMIT remain
+            return post.comments
+                .map(commentId => { var _a; return (_a = pullFromCache(['comment', 'get', commentId])) === null || _a === void 0 ? void 0 : _a.data; })
+                .filter(isPreviewableComment)
+                .slice(-LATEST_COMMENTS_LIMIT)
+                .map(commentLinkedObject);
         },
         get creator() {
             // The id is checked for a value, not just for presence: a payload can
@@ -13038,6 +13814,15 @@ const postLinkedObject = (post) => {
                 return undefined;
             return userLinkedObject(cacheData.data);
         },
+        getLocalCommentCount(includePending = false) {
+            var _a;
+            const engine = PostCommentCountEngine$1.getInstance();
+            // Before any payload has seeded the engine for this post there is no tracker; the
+            // post's own figure is the best answer then.
+            return engine.hasTracker(post.postId)
+                ? engine.getLocalCommentCount(post.postId, includePending)
+                : (_a = post.localCommentCount) !== null && _a !== void 0 ? _a : post.commentsCount;
+        },
         get targetCommunity() {
             var _a;
             if (!post.targetId)
@@ -13402,7 +14187,8 @@ const messageLinkedObject = (message) => {
         },
         get creator() {
             var _a;
-            return (_a = pullFromCache(['user', 'get', message.creatorId])) === null || _a === void 0 ? void 0 : _a.data;
+            const creator = (_a = pullFromCache(['user', 'get', message.creatorId])) === null || _a === void 0 ? void 0 : _a.data;
+            return creator ? userLinkedObject(creator) : undefined;
         }, markRead: () => markReadMessage(message), addReaction: (reactionName) => addReactionToMessage(reactionName, message), removeReaction: (reactionName) => removeReactionToMessage(reactionName, message) });
 };
 
@@ -14063,6 +14849,22 @@ const eventLinkedObject = (event) => {
         } });
 };
 
+const curatedContentTopicLinkedObject = (topic) => {
+    return shallowClone(topic, {
+        analytics: {
+            markAsViewed: () => {
+                AnalyticsEngine$1.getInstance().markCuratedContentWidgetAsViewed(topic.topicId);
+            },
+            markPostAsViewed: (postId) => {
+                AnalyticsEngine$1.getInstance().markCuratedContentPostAsViewed(postId, topic.topicId);
+            },
+            markPostClick: (postId) => {
+                AnalyticsEngine$1.getInstance().markCuratedContentPostAsClicked(postId, topic.topicId);
+            },
+        },
+    });
+};
+
 const LinkedObject = {
     file: fileLinkedObject,
     ad: adLinkedObject,
@@ -14087,6 +14889,7 @@ const LinkedObject = {
     eventResponse: eventResponseLinkedObject,
     product: productLinkedObject,
     poll: pollLinkedObject,
+    curatedContentTopic: curatedContentTopicLinkedObject,
 };
 
 /* begin_public_function
@@ -15409,9 +16212,9 @@ var AmityUserSearchMatchType;
     AmityUserSearchMatchType["PARTIAL"] = "partial";
 })(AmityUserSearchMatchType || (AmityUserSearchMatchType = {}));
 
-var index$q = /*#__PURE__*/Object.freeze({
+var index$r = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Relationship: index$r,
+    Relationship: index$s,
     getUserByIds: getUserByIds,
     updateUser: updateUser,
     flagUser: flagUser,
@@ -15819,7 +16622,7 @@ const uploadAudio = async (formData, onProgress) => {
 };
 /* end_public_function */
 
-var index$p = /*#__PURE__*/Object.freeze({
+var index$q = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getFile: getFile,
     uploadFile: uploadFile,
@@ -16012,147 +16815,6 @@ getMessage$1.locally = (messageId) => {
     };
 };
 
-class ResetTask {
-    constructor(postId, latestCreatedAt, serverCommentCount) {
-        this.postId = postId;
-        this.latestCreatedAt = latestCreatedAt;
-        this.serverCommentCount = serverCommentCount;
-    }
-}
-
-// Task to track comment creation
-class CreateTask {
-    constructor(postId, commentId, createdAt) {
-        this.postId = postId;
-        this.commentId = commentId;
-        this.createdAt = createdAt;
-    }
-}
-
-// Task to track comment deletion
-class DeleteTask {
-    constructor(postId, commentId) {
-        this.postId = postId;
-        this.commentId = commentId;
-    }
-}
-
-class CommentChange {
-    constructor(latestCreatedAt, serverCommentCount) {
-        this.latestCommentCreatedAt = latestCreatedAt;
-        this.serverCommentCount = serverCommentCount;
-        this.createdCommentIds = new Set();
-        this.deletedCommentIds = new Set();
-    }
-}
-
-class PostCommentCountEngine {
-    constructor() {
-        this.isProcessing = false;
-        this.tasks = [];
-        this.commentChangeTracker = new Map();
-    }
-    queueCommentChangeTask(task) {
-        this.tasks.push(task);
-        if (!this.isProcessing) {
-            this.processCommentChangeTask();
-        }
-    }
-    processCommentChangeTask() {
-        if (this.isProcessing) {
-            return;
-        }
-        this.isProcessing = true;
-        if (this.tasks.length === 0) {
-            this.isProcessing = false;
-            return;
-        }
-        // Process in capped batches, coalescing updates
-        const batch = this.tasks.splice(0, PostCommentCountEngine.BATCH_SIZE);
-        const modifiedPostIds = new Set();
-        batch.forEach(task => {
-            let modified = false;
-            if (task instanceof ResetTask) {
-                modified = this.processResetTaskInternal(task);
-            }
-            else if (task instanceof CreateTask) {
-                modified = this.processCreateTaskInternal(task);
-            }
-            else if (task instanceof DeleteTask) {
-                modified = this.processDeleteTaskInternal(task);
-            }
-            if (modified) {
-                modifiedPostIds.add(task.postId);
-            }
-        });
-        // Publish one update per modified post
-        modifiedPostIds.forEach(postId => {
-            const count = this.computeCommentCount(postId);
-            PostCommentCountEngine.publishUpdate(postId, count);
-        });
-        this.isProcessing = false;
-        // Recurse if more tasks remain
-        if (this.tasks.length > 0) {
-            this.processCommentChangeTask();
-        }
-    }
-    processResetTaskInternal(task) {
-        // Always creates/overwrites tracker
-        this.commentChangeTracker.set(task.postId, new CommentChange(task.latestCreatedAt, task.serverCommentCount));
-        return true;
-    }
-    processCreateTaskInternal(task) {
-        const tracker = this.commentChangeTracker.get(task.postId);
-        if (!tracker)
-            return false; // No tracker, skip
-        if (tracker.createdCommentIds.has(task.commentId))
-            return false; // Deduplication
-        if (task.createdAt <= tracker.latestCommentCreatedAt)
-            return false; // Timestamp filtering
-        tracker.createdCommentIds.add(task.commentId);
-        return true;
-    }
-    processDeleteTaskInternal(task) {
-        const tracker = this.commentChangeTracker.get(task.postId);
-        if (!tracker)
-            return false; // No tracker, skip
-        if (tracker.deletedCommentIds.has(task.commentId))
-            return false; // Deduplication
-        tracker.deletedCommentIds.add(task.commentId);
-        return true;
-    }
-    computeCommentCount(postId) {
-        const tracker = this.commentChangeTracker.get(postId);
-        if (!tracker)
-            return 0;
-        const count = tracker.serverCommentCount + tracker.createdCommentIds.size - tracker.deletedCommentIds.size;
-        return Math.max(0, count);
-    }
-    static publishUpdate(postId, newCount) {
-        var _a;
-        const queryKey = ['post', 'get', postId];
-        mergeInCache(queryKey, {
-            localCommentCount: newCount,
-        });
-        const postPayload = (_a = pullFromCache(queryKey)) === null || _a === void 0 ? void 0 : _a.data;
-        if (!postPayload)
-            return;
-        fireEvent('local.post.updated', {
-            posts: [postPayload],
-        });
-    }
-}
-PostCommentCountEngine.BATCH_SIZE = 50;
-let instance;
-var PostCommentCountEngine$1 = {
-    getInstance: () => {
-        if (!instance) {
-            instance = new PostCommentCountEngine();
-        }
-        return instance;
-    },
-};
-
 const updateStreamReferences = (streams, streamId, postId) => {
     if (!streamId)
         return streams;
@@ -16172,7 +16834,7 @@ const preparePostPayload = (payload) => {
     let mappedNewStream = [];
     // feed type
     const posts = postsData.map(post => {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
         const feedType = (_a = postPayload.feeds.find(feed => feed.feedId === post.feedId)) === null || _a === void 0 ? void 0 : _a.feedType;
         const childPosts = payload.postChildren.filter(children => children.parentPostId === post.postId);
         if (childPosts.length > 0 && isAmityLivestreamPost(childPosts[0])) {
@@ -16191,7 +16853,11 @@ const preparePostPayload = (payload) => {
         // Queue ResetTask for this post
         PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new ResetTask(post.postId, latestCreatedAt, (_c = post.commentsCount) !== null && _c !== void 0 ? _c : 0));
         return Object.assign(Object.assign({}, post), { childPosts,
-            feedType, localCommentCount: (_d = post.localCommentCount) !== null && _d !== void 0 ? _d : post.commentsCount, pinnedProductId: post === null || post === void 0 ? void 0 : post.pinnedProductId });
+            feedType, 
+            // The ResetTask above has just seeded the engine, so this is the server figure plus the
+            // author's own pending comments. Reading `post.commentsCount` here instead would overwrite
+            // that +1 in the cache on every refresh, since the ingest that follows merges this object.
+            localCommentCount: PostCommentCountEngine$1.getInstance().getLocalCommentCount(post.postId, true), pinnedProductId: post === null || post === void 0 ? void 0 : post.pinnedProductId });
     });
     return Object.assign(Object.assign({}, postPayload), { postChildren, videoStreamings: mappedNewStream, posts, communities: communityWithMembershipStatus, communityUsers: mappedCommunityUsers });
 };
@@ -16944,62 +17610,67 @@ const onPostReactionRemoved = (callback) => {
     return createEventSubscriber(client, 'post.removeReaction', 'post.removeReaction', filter);
 };
 
+/**
+ * `comment.created` fires while a comment is still pending, so delivery is not visibility. The
+ * two side effects that make a comment public — the parent link that feeds the reply list and
+ * the comment-count task — are gated here; `comment.approved` is the only reveal signal, and a
+ * decline arrives as `comment.deleted`.
+ */
+const applyApprovalSideEffects = (event, comment, previous) => {
+    switch (event) {
+        case 'comment.created':
+            if (isCommentPending(comment)) {
+                recordPendingAuthoredComment(comment);
+            }
+            else {
+                linkCommentToParent(comment);
+                applyCommentCreatedCount(comment);
+            }
+            break;
+        case 'comment.approved':
+            linkCommentToParent(comment);
+            applyCommentApprovedCount(comment);
+            break;
+        case 'comment.updated':
+            // An effective edit in a gated community sends an approved comment back for review
+            if (isCommentPending(comment) && previous && isCommentApproved(previous)) {
+                unlinkCommentFromParent(comment);
+                applyCommentReReviewCount(comment);
+            }
+            break;
+        case 'comment.deleted':
+            unlinkCommentFromParent(comment);
+            // A pending comment was never counted, so its deletion (or decline) moves no count
+            if (previous && isCommentPending(previous))
+                releasePendingAuthoredComment(comment);
+            break;
+    }
+};
 const createCommentEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        var _a;
+        var _a, _b;
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
             callback(LinkedObject.comment(payload.comments[0]));
         }
         else {
-            const processed = ['comment.flagged', 'comment.unflagged'].includes(event)
+            const flagged = ['comment.flagged', 'comment.unflagged'].includes(event)
                 ? prepareCommentFromFlaggedEvent(payload)
                 : payload;
-            // NOTE: The event data should be merge with existing cache rather than replace it
-            ingestInCache(processed, undefined, false);
+            // Resolve `approvalStatus` before the merge: an absent value means approved and has to
+            // overwrite a cached `pending`, which a plain merge would leave in place.
+            const processed = prepareCommentPayload(flagged);
             const { comments } = processed;
             if (comments.length > 0) {
-                const comment = pullFromCache([
-                    'comment',
-                    'get',
-                    comments[0].commentId,
-                ]);
-                if (['comment.created'].includes(event)) {
-                    if (comments[0].parentId) {
-                        const parentComment = pullFromCache([
-                            'comment',
-                            'get',
-                            comments[0].parentId,
-                        ]);
-                        if (parentComment === null || parentComment === void 0 ? void 0 : parentComment.data) {
-                            // Skip to update parent childComment if current comment already exists
-                            if (!parentComment.data.children.includes(comments[0].commentId)) {
-                                pushToCache(['comment', 'get', comments[0].parentId], Object.assign(Object.assign({}, parentComment.data), { childrenNumber: parentComment.data.childrenNumber + 1, children: [...new Set([...parentComment.data.children, comments[0].commentId])] }));
-                            }
-                        }
-                    }
-                }
+                const commentKey = ['comment', 'get', comments[0].commentId];
+                const previous = (_a = pullFromCache(commentKey)) === null || _a === void 0 ? void 0 : _a.data;
+                // NOTE: The event data should be merge with existing cache rather than replace it
+                ingestInCache(processed, undefined, false);
+                const comment = pullFromCache(commentKey);
+                applyApprovalSideEffects(event, comment.data, previous);
                 if (['comment.deleted'].includes(event)) {
-                    if (comments[0].parentId) {
-                        const parentComment = pullFromCache([
-                            'comment',
-                            'get',
-                            comments[0].parentId,
-                        ]);
-                        if (parentComment === null || parentComment === void 0 ? void 0 : parentComment.data) {
-                            // Remove deleted comment in parent childComment if still exists
-                            if (parentComment.data.children.includes(comments[0].commentId)) {
-                                const newParentComment = Object.assign(Object.assign({}, parentComment.data), { childrenNumber: parentComment.data.childrenNumber - 1, children: [
-                                        ...new Set([
-                                            ...parentComment.data.children.filter(id => id !== comments[0].commentId),
-                                        ]),
-                                    ] });
-                                pushToCache(['comment', 'get', comments[0].parentId], newParentComment);
-                            }
-                        }
-                    }
-                    const queries = (_a = queryCache(['comment', 'query'])) === null || _a === void 0 ? void 0 : _a.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
+                    const queries = (_b = queryCache(['comment', 'query'])) === null || _b === void 0 ? void 0 : _b.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
                     queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
                 }
                 callback(LinkedObject.comment(comment.data));
@@ -17011,13 +17682,13 @@ const createCommentEventSubscriber = (event, callback) => {
 const createLocalCommentEventSubscriber = (event, callback) => {
     const client = getActiveClient();
     const filter = (payload) => {
-        var _a, _b, _c, _d, _e;
+        var _a, _b, _c, _d;
         if (!client.cache) {
             // TODO: here we are missing specific properties here!
             callback(LinkedObject.comment(payload.comments[0]));
         }
         else {
-            const processed = payload;
+            const processed = prepareCommentPayload(payload);
             ingestInCache(processed);
             const { comments } = processed;
             if (comments.length > 0) {
@@ -17026,7 +17697,9 @@ const createLocalCommentEventSubscriber = (event, callback) => {
                     'get',
                     comments[0].commentId,
                 ]);
-                if (['local.comment.created'].includes(event)) {
+                // A pending comment is persisted for its author but never linked into the public
+                // surfaces (parent reply list, post comment list)
+                if (['local.comment.created'].includes(event) && isCommentApproved(comments[0])) {
                     if (comments[0].parentId) {
                         const parentComment = pullFromCache([
                             'comment',
@@ -17055,11 +17728,11 @@ const createLocalCommentEventSubscriber = (event, callback) => {
                         const postCacheKey = ['post', 'get', comments[0].referenceId];
                         const postCache = (_a = pullFromCache(postCacheKey)) === null || _a === void 0 ? void 0 : _a.data;
                         if (postCache) {
-                            const updatedPostCache = Object.assign(Object.assign({}, postCache), { comments: [...postCache.comments, (_b = comments[0]) === null || _b === void 0 ? void 0 : _b.commentId] });
+                            const updatedPostCache = Object.assign(Object.assign({}, postCache), { comments: appendLatestCommentId(postCache, comments[0].commentId) });
                             pushToCache(postCacheKey, updatedPostCache);
                         }
                     }
-                    const queries = (_c = queryCache(['comment', 'query'])) === null || _c === void 0 ? void 0 : _c.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
+                    const queries = (_b = queryCache(['comment', 'query'])) === null || _b === void 0 ? void 0 : _b.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
                     queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
                 }
                 if (['local.comment.deleted'].includes(event)) {
@@ -17093,13 +17766,13 @@ const createLocalCommentEventSubscriber = (event, callback) => {
                     }
                     else {
                         const postCacheKey = ['post', 'get', comments[0].referenceId];
-                        const postCache = (_d = pullFromCache(postCacheKey)) === null || _d === void 0 ? void 0 : _d.data;
+                        const postCache = (_c = pullFromCache(postCacheKey)) === null || _c === void 0 ? void 0 : _c.data;
                         if (postCache) {
                             const updatedPost = Object.assign(Object.assign({}, postCache), { comments: postCache === null || postCache === void 0 ? void 0 : postCache.comments.filter(commentId => { var _a; return commentId !== ((_a = comments[0]) === null || _a === void 0 ? void 0 : _a.commentId); }) });
                             pushToCache(postCacheKey, updatedPost);
                         }
                     }
-                    const queries = (_e = queryCache(['comment', 'query'])) === null || _e === void 0 ? void 0 : _e.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
+                    const queries = (_d = queryCache(['comment', 'query'])) === null || _d === void 0 ? void 0 : _d.filter(({ key }) => { var _a; return ((_a = key[2]) === null || _a === void 0 ? void 0 : _a.referenceId) === comment.data.referenceId; });
                     queries === null || queries === void 0 ? void 0 : queries.map(({ key, data }) => upsertInCache(key, data, { cachedAt: -1 }));
                 }
                 callback(LinkedObject.comment(comment.data));
@@ -17160,6 +17833,23 @@ const onCommentUpdated = (callback) => createCommentEventSubscriber('comment.upd
  */
 const onCommentDeleted = (callback) => createCommentEventSubscriber('comment.deleted', callback);
 
+/**
+ * ```js
+ * import { onCommentApproved } from '@amityco/ts-sdk'
+ * const dispose = onCommentApproved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} held for review has been approved
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentApproved = (callback) => createCommentEventSubscriber('comment.approved', callback);
+
 /**
  * ```js
  * import { onCommentFlagged } from '@amityco/ts-sdk'
@@ -17792,7 +18482,7 @@ const getReactions$1 = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$o = /*#__PURE__*/Object.freeze({
+var index$p = /*#__PURE__*/Object.freeze({
     __proto__: null,
     addReaction: addReaction,
     removeReaction: removeReaction,
@@ -17803,17 +18493,6 @@ var index$o = /*#__PURE__*/Object.freeze({
     getReactions: getReactions$1
 });
 
-function prepareCommentPayload(commentPayload) {
-    const { comments } = commentPayload;
-    return Object.assign(Object.assign({}, commentPayload), { comments: comments.map(comment => {
-            if (comment.hasOwnProperty('myReactions'))
-                return comment;
-            // Sometimes `myReactions` field will not come with BE response because that field is empty
-            // We need to put it with an empty array manually to make it show up in client side
-            return Object.assign({ myReactions: [] }, comment);
-        }) });
-}
-
 const createMessageReport = async ({ client, referenceId, }) => {
     const { data: payload } = await client.http.post(`/api/v5/messages/${encodeURIComponent(referenceId)}/flags`);
     if (client.cache) {
@@ -18277,20 +18956,20 @@ const getArchivedChannelIds = async () => {
 
 /**
  * ```js
- * import { onMessageUpdated } from '@amityco/ts-sdk'
- * const dispose = onMessageUpdated(message => {
+ * import { onMessageDeleted } from '@amityco/ts-sdk'
+ * const dispose = onMessageDeleted(message => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} has been updated
+ * Fired when an {@link Amity.Message} was deleted
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Message Events
  */
-const onMessageUpdated = (callback) => {
+const onMessageDeleted = (callback) => {
     const client = getActiveClient();
     const filter = async (rawPayload) => {
         const payload = await prepareMessagePayload(rawPayload);
@@ -18298,30 +18977,48 @@ const onMessageUpdated = (callback) => {
         callback(payload.messages[0]);
     };
     const disposers = [
-        createEventSubscriber(client, 'onMessageUpdated', 'message.updated', filter),
-        createEventSubscriber(client, 'onMessageUpdated', 'local.message.updated', payload => callback(payload.messages[0])),
+        createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
+        createEventSubscriber(client, 'message/onMessageDeleted', 'local.message.deleted', payload => callback(payload.messages[0])),
     ];
     return () => {
         disposers.forEach(fn => fn());
     };
 };
 
+/**
+ * Defensive clear of `channel.pinnedMessage` when the pinned message itself is deleted.
+ *
+ * The server also emits `channel.messageUnpinned` in this case, but realtime events are
+ * fire-and-forget and their order is not guaranteed. Clearing on `message.deleted`
+ * (MQTT or local) makes the banner disappear even if the unpin event is lost; the
+ * server's own `messageUnpinned` then becomes a no-op.
+ *
+ * Internal — wired into the `getChannel` live object; not exported publicly.
+ */
+const onChannelPinnedMessageDeleted = (callback) => onMessageDeleted(message => {
+    var _a;
+    const channel = findCachedChannelByAnyId(message.channelId);
+    if (!channel || ((_a = channel.pinnedMessage) === null || _a === void 0 ? void 0 : _a.messageId) !== message.messageId)
+        return;
+    callback(updatePinnedMessageCache(channel, null));
+});
+
 /**
  * ```js
- * import { onMessageDeleted } from '@amityco/ts-sdk'
- * const dispose = onMessageDeleted(message => {
+ * import { onMessageUpdated } from '@amityco/ts-sdk'
+ * const dispose = onMessageUpdated(message => {
  *   // ...
  * })
  * ```
  *
- * Fired when an {@link Amity.Message} was deleted
+ * Fired when an {@link Amity.Message} has been updated
  *
  * @param callback The function to call when the event was fired
  * @returns an {@link Amity.Unsubscriber} function to stop listening
  *
  * @category Message Events
  */
-const onMessageDeleted = (callback) => {
+const onMessageUpdated = (callback) => {
     const client = getActiveClient();
     const filter = async (rawPayload) => {
         const payload = await prepareMessagePayload(rawPayload);
@@ -18329,8 +19026,8 @@ const onMessageDeleted = (callback) => {
         callback(payload.messages[0]);
     };
     const disposers = [
-        createEventSubscriber(client, 'message/onMessageDeleted', 'message.deleted', filter),
-        createEventSubscriber(client, 'message/onMessageDeleted', 'local.message.deleted', payload => callback(payload.messages[0])),
+        createEventSubscriber(client, 'onMessageUpdated', 'message.updated', filter),
+        createEventSubscriber(client, 'onMessageUpdated', 'local.message.updated', payload => callback(payload.messages[0])),
     ];
     return () => {
         disposers.forEach(fn => fn());
@@ -18911,6 +19608,132 @@ softDeleteMessage.optimistically = (messageId) => {
 };
 /* end_public_function */
 
+/**
+ * Fire-and-forget refresh of `channelUsers[...].permissions` for the channel a
+ * message belongs to. Used by `pinMessage` / `unpinMessage` on `403` so the next
+ * `hasPermission(PIN_MESSAGE).channel(channelId)` reflects a revoked role
+ * ([`pinMessage` REQ-010](../../@types/../..) / [`unpinMessage` REQ-008](../../@types/../..)).
+ *
+ * The API only receives a `messageId`, so the channel is resolved through the
+ * local cache: first the message row, then any cached channel whose current pin
+ * is that message. When nothing matches the refresh is skipped — the next
+ * channel read picks up the fresh permissions anyway.
+ */
+const refreshChannelPermissionsForMessage = (messageId) => {
+    var _a, _b, _c;
+    const cachedMessage = (_a = getMessage$1.locally(messageId)) === null || _a === void 0 ? void 0 : _a.data;
+    let channelId = cachedMessage === null || cachedMessage === void 0 ? void 0 : cachedMessage.channelId;
+    if (!channelId) {
+        channelId = (_c = (_b = queryCache(['channel', 'get'])) === null || _b === void 0 ? void 0 : _b.find(({ data }) => { var _a; return ((_a = data.pinnedMessage) === null || _a === void 0 ? void 0 : _a.messageId) === messageId; })) === null || _c === void 0 ? void 0 : _c.data.channelId;
+    }
+    if (!channelId)
+        return;
+    getChannel$1(channelId).catch(() => {
+        /* silent per spec; UIKit renders no error toast */
+    });
+};
+
+/* begin_public_function
+  id: message.pin
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const channel = await MessageRepository.pinMessage(messageId)
+ * console.log(channel.pinnedMessage)
+ * ```
+ *
+ * Pins a {@link Amity.Message} in its livestream (`live`) channel. A channel holds at
+ * most one pinned message: pinning a different message replaces the current pin in a
+ * single step — no unpin is needed first. Pinning the message that is already pinned is
+ * rejected by the server (400).
+ *
+ * The caller must hold the `PIN_MESSAGE` permission in the channel (or be an admin with
+ * `ModerateChannel`). The server also rejects pinning a deleted message, a message whose
+ * author is banned from the channel or globally banned, and pinning in any channel type
+ * other than `live`. On any error the pin state is left unchanged.
+ *
+ * The response is the affected channel; it is ingested into cache and fires
+ * `local.channel.updated`, so `ChannelRepository.getChannel` observers update without
+ * waiting for the `channel.messagePinned` realtime event.
+ *
+ * @param messageId the **internal** ID of the {@link Amity.Message} to pin
+ * @returns the updated {@link Amity.Channel}, with `pinnedMessage` set
+ *
+ * @category Message API
+ * @async
+ */
+const pinMessage = async (messageId) => {
+    const client = getActiveClient();
+    client.log('message/pinMessage', messageId);
+    let payload;
+    try {
+        ({ data: payload } = await client.http.post(`/api/v5/messages/${encodeURIComponent(messageId)}/pin`));
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 400301 /* Amity.ServerError.PERMISSION_DENIED */) {
+            refreshChannelPermissionsForMessage(messageId);
+        }
+        throw error;
+    }
+    const data = await prepareChannelPayload(payload);
+    if (client.cache)
+        ingestInCache(data);
+    fireEvent('local.channel.updated', data);
+    return constructChannelObject(data.channels[0]);
+};
+/* end_public_function */
+
+/* begin_public_function
+  id: message.unpin
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const channel = await MessageRepository.unpinMessage(messageId)
+ * console.log(channel.pinnedMessage) // null
+ * ```
+ *
+ * Removes the pin from a {@link Amity.Message}. `messageId` must be the message that is
+ * **currently** pinned in its channel; otherwise the server answers 400 — this is
+ * deliberate, so a stale client cannot clear a pin that someone else has since replaced.
+ * On that error, re-read the channel (or rely on the `channel.messagePinned` event) to
+ * get the current pin.
+ *
+ * The caller must hold the `PIN_MESSAGE` permission in the channel (or be an admin with
+ * `ModerateChannel`). Unpinning is allowed regardless of channel type and stream state.
+ *
+ * The response is the affected channel; it is ingested into cache and fires
+ * `local.channel.updated`, so `ChannelRepository.getChannel` observers update without
+ * waiting for the `channel.messageUnpinned` realtime event.
+ *
+ * @param messageId the **internal** ID of the currently pinned {@link Amity.Message}
+ * @returns the updated {@link Amity.Channel}, with `pinnedMessage` cleared
+ *
+ * @category Message API
+ * @async
+ */
+const unpinMessage = async (messageId) => {
+    const client = getActiveClient();
+    client.log('message/unpinMessage', messageId);
+    let payload;
+    try {
+        ({ data: payload } = await client.http.delete(`/api/v5/messages/${encodeURIComponent(messageId)}/pin`));
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) === 400301 /* Amity.ServerError.PERMISSION_DENIED */) {
+            refreshChannelPermissionsForMessage(messageId);
+        }
+        throw error;
+    }
+    const data = await prepareChannelPayload(payload);
+    if (client.cache)
+        ingestInCache(data);
+    fireEvent('local.channel.updated', data);
+    return constructChannelObject(data.channels[0]);
+};
+/* end_public_function */
+
 /**
  * ```js
  * import { MessageRepository } from '@amityco/ts-sdk'
@@ -19807,13 +20630,15 @@ const searchMessage = (params, callback) => {
 };
 /* end_public_function */
 
-var index$n = /*#__PURE__*/Object.freeze({
+var index$o = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createMessage: createMessage,
     updateMessage: updateMessage,
     editMessage: editMessage,
     deleteMessage: deleteMessage,
     softDeleteMessage: softDeleteMessage,
+    pinMessage: pinMessage,
+    unpinMessage: unpinMessage,
     markAsDelivered: markAsDelivered,
     getReadUsers: getReadUsers,
     getDeliveredUsers: getDeliveredUsers,
@@ -20343,7 +21168,7 @@ const stopMessageReceiptSync = (subChannelId) => {
 };
 /* end_public_function */
 
-var index$m = /*#__PURE__*/Object.freeze({
+var index$n = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getSubChannelByIds: getSubChannels$1,
     createSubChannel: createSubChannel,
@@ -20451,6 +21276,9 @@ const getChannel = (channelId, callback) => {
         onChannelMemberBanned,
         onChannelMemberUnbanned,
         onChannelSetMuted,
+        onChannelMessagePinned,
+        onChannelMessageUnpinned,
+        onChannelPinnedMessageDeleted,
         convertEventPayload(onChannelMarkerFetched, 'entityId', 'channel'),
         convertEventPayload(onChannelMarkerUpdated, 'entityId', 'channel'),
         convertEventPayload((callback) => {
@@ -21076,6 +21904,14 @@ class ChannelLiveCollectionController extends LiveCollectionController {
                             return;
                         if (messagePreviewSetting ===
                             "message-preview-not-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED */) {
+                            // The replacement preview the server sends back is an OLDER
+                            // message than the one just deleted, and
+                            // updateChannelMessagePreviewCache drops any preview that is not
+                            // newer than what is cached — so without clearing the entry
+                            // first the refetch is a no-op and the channel keeps showing the
+                            // deleted message. getChannel's own live object already does
+                            // this; the live collections did not.
+                            dropFromCache(['messagePreviewChannel', 'get', message.channelId]);
                             await getChannel$1(message.channelId);
                         }
                         callback(message);
@@ -21800,6 +22636,14 @@ class SearchChannelLiveCollectionController extends LiveCollectionController {
                             return;
                         if (messagePreviewSetting ===
                             "message-preview-not-include-deleted" /* Amity.MessagePreviewSetting.MESSAGE_PREVIEW_NOT_INCLUDE_DELETED */) {
+                            // The replacement preview the server sends back is an OLDER
+                            // message than the one just deleted, and
+                            // updateChannelMessagePreviewCache drops any preview that is not
+                            // newer than what is cached — so without clearing the entry
+                            // first the refetch is a no-op and the channel keeps showing the
+                            // deleted message. getChannel's own live object already does
+                            // this; the live collections did not.
+                            dropFromCache(['messagePreviewChannel', 'get', message.channelId]);
                             await getChannel$1(message.channelId);
                         }
                         callback(message);
@@ -22294,7 +23138,7 @@ const searchMembers$1 = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$l = /*#__PURE__*/Object.freeze({
+var index$m = /*#__PURE__*/Object.freeze({
     __proto__: null,
     addMembers: addMembers$1,
     removeMembers: removeMembers$1,
@@ -22516,7 +23360,7 @@ const unmuteMembers = async (channelId, userIds) => {
 };
 /* end_public_function */
 
-var index$k = /*#__PURE__*/Object.freeze({
+var index$l = /*#__PURE__*/Object.freeze({
     __proto__: null,
     addRole: addRole,
     removeRole: removeRole,
@@ -22526,10 +23370,10 @@ var index$k = /*#__PURE__*/Object.freeze({
     unmuteMembers: unmuteMembers
 });
 
-var index$j = /*#__PURE__*/Object.freeze({
+var index$k = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Membership: index$l,
-    Moderation: index$k,
+    Membership: index$m,
+    Moderation: index$l,
     getChannelByIds: getChannelByIds$1,
     createChannel: createChannel,
     updateChannel: updateChannel,
@@ -22547,6 +23391,8 @@ var index$j = /*#__PURE__*/Object.freeze({
     onChannelJoined: onChannelJoined,
     onChannelLeft: onChannelLeft,
     onChannelSetMuted: onChannelSetMuted,
+    onChannelMessagePinned: onChannelMessagePinned,
+    onChannelMessageUnpinned: onChannelMessageUnpinned,
     onChannelMemberAdded: onChannelMemberAdded,
     onChannelMemberRemoved: onChannelMemberRemoved,
     onChannelMemberBanned: onChannelMemberBanned,
@@ -22564,7 +23410,11 @@ var index$j = /*#__PURE__*/Object.freeze({
     isUnreadCountSupport: isUnreadCountSupport,
     convertFromRaw: convertFromRaw,
     preUpdateChannelCache: preUpdateChannelCache,
-    prepareChannelPayload: prepareChannelPayload
+    prepareChannelPayload: prepareChannelPayload,
+    findCachedChannelByAnyId: findCachedChannelByAnyId,
+    findCachedChannelForPin: findCachedChannelForPin,
+    updatePinnedMessageCache: updatePinnedMessageCache,
+    applyChannelRolePayload: applyChannelRolePayload
 });
 
 const saveCommunityUsers = (communities, communityUsers) => {
@@ -23958,7 +24808,7 @@ const searchMembers = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$i = /*#__PURE__*/Object.freeze({
+var index$j = /*#__PURE__*/Object.freeze({
     __proto__: null,
     addMembers: addMembers,
     removeMembers: removeMembers,
@@ -25209,7 +26059,7 @@ const unbanMembers = async (communityId, userIds) => {
 };
 /* end_public_function */
 
-var index$h = /*#__PURE__*/Object.freeze({
+var index$i = /*#__PURE__*/Object.freeze({
     __proto__: null,
     addRoles: addRoles,
     removeRoles: removeRoles,
@@ -25217,10 +26067,10 @@ var index$h = /*#__PURE__*/Object.freeze({
     unbanMembers: unbanMembers
 });
 
-var index$g = /*#__PURE__*/Object.freeze({
+var index$h = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    Moderation: index$h,
-    Membership: index$i,
+    Moderation: index$i,
+    Membership: index$j,
     getCommunityByIds: getCommunities$1,
     createCommunity: createCommunity,
     updateCommunity: updateCommunity,
@@ -25456,7 +26306,7 @@ const getCategories = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$f = /*#__PURE__*/Object.freeze({
+var index$g = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getCategory: getCategory,
     getCategories: getCategories
@@ -25755,6 +26605,11 @@ const createCommentOptimistic = (bundle) => {
         targetType: 'community',
         dataType: 'text',
         syncState: "syncing" /* Amity.SyncState.Syncing */,
+        // In a gated community the optimistic object stays out of public collections until the
+        // response settles the status; the author's own view still updates through the local event
+        approvalStatus: isCommentApprovalRequired(bundle)
+            ? "pending" /* Amity.CommentApprovalStatusEnum.Pending */
+            : "approved" /* Amity.CommentApprovalStatusEnum.Approved */,
     };
     const cachedAt = UNSYNCED_OBJECT_CACHED_AT_VALUE;
     pushToCache(['comment', 'get', comment.commentId], comment, { cachedAt });
@@ -25771,32 +26626,57 @@ const createCommentOptimistic = (bundle) => {
  * ```js
  * import { CommentRepository } from '@amityco/ts-sdk'
  * const newComment = await CommentRepository.createComment(bundle)
+ *
+ * // Server-confirmed only: nothing is shown until the request succeeds
+ * const confirmed = await CommentRepository.createComment(bundle, false)
  * ```
  *
  * Creates an {@link Amity.Comment}
  *
+ * With `isOptimistic` (the default) a local comment appears at once with `syncState: 'syncing'`,
+ * moves to `'synced'` when the server confirms it and to `'error'` if the request fails, so the
+ * caller can offer a retry. With `isOptimistic: false` nothing is created locally until the
+ * server answers: on success the comment arrives already `'synced'`; on failure no comment
+ * entity exists anywhere and the promise rejects.
+ *
  * @param bundle The data necessary to create a new {@link Amity.Comment}
+ * @param isOptimistic Show a local comment before the server confirms it. Default `true`.
+ *   Ignored when the client cache is disabled, since there is nowhere to hold the local comment.
  * @returns The newly created {@link Amity.Comment}
  *
  * @category Comment API
  * @async
  */
-const createComment = async (bundle) => {
+const createComment = async (bundle, isOptimistic = true) => {
     const client = getActiveClient();
-    client.log('comment/createComment', bundle);
-    const optimisticData = createCommentOptimistic(bundle);
+    client.log('comment/createComment', Object.assign(Object.assign({}, bundle), { isOptimistic }));
+    // Without a local comment the server assigns the id; with one, the same id travels through the
+    // optimistic object, the response and every realtime event so each step recognises it.
+    const optimisticData = isOptimistic ? createCommentOptimistic(bundle) : undefined;
     const commentId = optimisticData === null || optimisticData === void 0 ? void 0 : optimisticData.commentId;
     try {
-        const { data } = await client.http.post('/api/v3/comments', Object.assign(Object.assign({}, bundle), { commentId }));
-        const { comments } = data;
+        const { data: payload } = await client.http.post('/api/v3/comments', Object.assign(Object.assign({}, bundle), { commentId }));
         // BE always returns an array of comments If it got record 0 from BE it might have a problem on creation logic
-        if (comments.length === 0)
+        if (payload.comments.length === 0)
             throw new Error('Comment not created');
+        // Absent `approvalStatus` means approved; the result is the only source of the status.
+        // The confirmed comment is written as `synced` so the cache itself tells the two states apart
+        // (a local-event subscriber is not guaranteed to be listening).
+        const prepared = prepareCommentPayload(payload);
+        const data = Object.assign(Object.assign({}, prepared), { comments: prepared.comments.map(comment => comment.commentId === (commentId !== null && commentId !== void 0 ? commentId : comment.commentId)
+                ? Object.assign(Object.assign({}, comment), { syncState: "synced" /* Amity.SyncState.Synced */ }) : comment) });
+        const { comments } = data;
         const cachedAt = client.cache && Date.now();
         if (client.cache)
             ingestInCache(data, { cachedAt });
         if (['post', 'content'].includes(bundle.referenceType)) {
-            PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new CreateTask(bundle.referenceId, comments[0].commentId, data.comments[0].createdAt));
+            if (isCommentPending(comments[0])) {
+                // Not counted for anyone else until approved; the author sees their own +1
+                recordPendingAuthoredComment(comments[0]);
+            }
+            else {
+                PostCommentCountEngine$1.getInstance().queueCommentChangeTask(new CreateTask(bundle.referenceId, comments[0].commentId, comments[0].createdAt));
+            }
         }
         else if (bundle.referenceType === 'story') {
             const storyIndex = pullFromCache([
@@ -25817,9 +26697,9 @@ const createComment = async (bundle) => {
                         categories: [],
                         comments,
                         communities: [],
-                        communityUsers: data.communityUsers,
-                        files: data.files,
-                        users: data.users,
+                        communityUsers: payload.communityUsers,
+                        files: payload.files,
+                        users: payload.users,
                     });
                 }
             }
@@ -25827,9 +26707,9 @@ const createComment = async (bundle) => {
         fireEvent('local.comment.created', {
             comments: [Object.assign(Object.assign({}, comments[0]), { syncState: "synced" /* Amity.SyncState.Synced */ })],
             commentChildren: data.commentChildren,
-            users: data.users,
-            files: data.files,
-            communityUsers: data.communityUsers,
+            users: payload.users,
+            files: payload.files,
+            communityUsers: payload.communityUsers,
         });
         return {
             data: LinkedObject.comment(comments[0]),
@@ -25837,9 +26717,17 @@ const createComment = async (bundle) => {
         };
     }
     catch (e) {
+        // Only a local comment has anything to mark as failed; a server-confirmed-only create leaves
+        // no entity behind
         if (optimisticData) {
+            const failed = Object.assign(Object.assign({}, optimisticData), { syncState: "error" /* Amity.SyncState.Error */ });
+            // Write the failure to the cache directly: the local event below only reaches pages that
+            // observe comments, and the caller's retry UI reads the cached state
+            pushToCache(['comment', 'get', failed.commentId], failed, {
+                cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+            });
             fireEvent('local.comment.created', {
-                comments: [Object.assign(Object.assign({}, optimisticData), { syncState: "error" /* Amity.SyncState.Error */ })],
+                comments: [failed],
                 commentChildren: [],
                 users: [],
                 files: [],
@@ -25872,16 +26760,26 @@ const createComment = async (bundle) => {
  * @async
  */
 const updateComment = async (commentId, patch) => {
+    var _a;
     const client = getActiveClient();
     client.log('user/updateComment', patch);
-    const { data } = await client.http.put(`/api/v3/comments/${encodeURIComponent(commentId)}`, patch);
+    const previous = (_a = pullFromCache(['comment', 'get', commentId])) === null || _a === void 0 ? void 0 : _a.data;
+    const { data: payload } = await client.http.put(`/api/v3/comments/${encodeURIComponent(commentId)}`, patch);
+    const data = prepareCommentPayload(payload);
+    const updated = data.comments.find(comment => comment.commentId === commentId);
     const cachedAt = client.cache && Date.now();
     if (client.cache)
         ingestInCache(data, { cachedAt });
-    fireEvent('comment.updated', data);
-    const { comments } = data;
+    // An effective edit in a gated community sends the comment back for review: it leaves the
+    // public reply list and the public count once. The `comment.updated` event below removes it
+    // from the comment collections; the realtime echo finds it already pending and does nothing.
+    if (isCommentPending(updated) && previous && isCommentApproved(previous)) {
+        unlinkCommentFromParent(updated);
+        applyCommentReReviewCount(updated);
+    }
+    fireEvent('comment.updated', payload);
     return {
-        data: LinkedObject.comment(comments.find(comment => comment.commentId === commentId)),
+        data: LinkedObject.comment(updated),
         cachedAt,
     };
 };
@@ -26021,7 +26919,13 @@ const deleteComment = async (commentId, permanent = false) => {
         const post = (_b = pullFromCache(['post', 'get', comment.data.referenceId])) === null || _b === void 0 ? void 0 : _b.data;
         if (post) {
             const engine = PostCommentCountEngine$1.getInstance();
-            engine.queueCommentChangeTask(new DeleteTask(post.postId, commentId));
+            if (isCommentPending(comment.data)) {
+                // Never counted for anyone else; only the author's own +1 goes away
+                engine.removePendingAuthoredComment(post.postId, commentId);
+            }
+            else {
+                engine.queueCommentChangeTask(new DeleteTask(post.postId, commentId));
+            }
             if (!deleted.parentId && ((_c = deleted.children /* c8 ignore next */) === null || _c === void 0 ? void 0 : _c.length) > 0) {
                 // NOTE: delete the parent comment will also remove all children comments
                 deleted.children.forEach((childCommentId) => {
@@ -26091,6 +26995,109 @@ const hardDeleteComment = async (commentId) => {
 };
 /* end_public_function */
 
+/* begin_public_function
+  id: comment.approve
+*/
+/**
+ * ```js
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ *
+ * const { data: comment } = await CommentRepository.approveComment('commentId')
+ * ```
+ *
+ * Approves a {@link Amity.Comment} held for review, making it visible to everyone
+ *
+ * @param commentId The {@link Amity.Comment} ID to be approved
+ * @return The {@link Amity.Comment} that was approved
+ *
+ * @category Comment API
+ * @async
+ */
+const approveComment = async (commentId) => {
+    const client = getActiveClient();
+    client.log('comment/approveComment', commentId);
+    // No request body, and nothing is revealed before the server confirms
+    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/approve`);
+    const data = prepareCommentPayload(prepareMembershipPayload(payload, 'communityUsers'));
+    const approved = data.comments.find(comment => comment.commentId === commentId);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    // The reveal path: parent link and exactly one count task. Applied here so it does not depend
+    // on an observer being open; the event below and the realtime `comment.approved` that follows
+    // find the work done and reconcile by comment id (collection insert, queue removal).
+    linkCommentToParent(approved);
+    applyCommentApprovedCount(approved);
+    fireEvent('comment.approved', payload);
+    return {
+        data: LinkedObject.comment(approved),
+        cachedAt,
+    };
+};
+/* end_public_function */
+
+// Rejected is terminal and implies deleted
+const markRejected = (comment) => (Object.assign(Object.assign({}, comment), { approvalStatus: "rejected" /* Amity.CommentApprovalStatusEnum.Rejected */, isDeleted: true }));
+/* begin_public_function
+  id: comment.decline
+*/
+/**
+ * ```js
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ *
+ * const { data: comment } = await CommentRepository.declineComment('commentId', 'Off-topic')
+ * ```
+ *
+ * Declines a {@link Amity.Comment} held for review. A declined comment is also a deleted comment
+ *
+ * @param commentId The {@link Amity.Comment} ID to be declined
+ * @param reason Optional reviewer's note, at most 250 characters, kept for the moderation record only
+ * @return The {@link Amity.Comment} that was declined
+ *
+ * @category Comment API
+ * @async
+ */
+const declineComment = async (commentId, reason) => {
+    var _a, _b, _c, _d, _e, _f;
+    const client = getActiveClient();
+    client.log('comment/declineComment', commentId, reason);
+    // Read before the request: the fallback when the response carries no comment
+    const cached = (_a = pullFromCache(['comment', 'get', commentId])) === null || _a === void 0 ? void 0 : _a.data;
+    // `reason` is surfaced to nobody; the key is absent from the body when the caller gives none
+    const { data: payload } = await client.http.post(`/api/v3/comments/${encodeURIComponent(commentId)}/decline`, reason ? { reason } : undefined);
+    // The BE contract (PDT-5135 §3) states the response body for approve only; for decline the
+    // standard comment payload is assumed. Ingest whatever came back, and when the body carries no
+    // comment fall back to the cached one so the delete path below still runs.
+    const returned = (_b = payload === null || payload === void 0 ? void 0 : payload.comments) === null || _b === void 0 ? void 0 : _b.some(comment => comment.commentId === commentId);
+    if (!returned && !cached)
+        throw new Error('Comment not found after decline');
+    const comments = returned
+        ? payload.comments.map(comment => comment.commentId === commentId ? markRejected(comment) : comment)
+        : [markRejected(cached)];
+    const declined = {
+        comments,
+        commentChildren: (_c = payload === null || payload === void 0 ? void 0 : payload.commentChildren) !== null && _c !== void 0 ? _c : [],
+        users: (_d = payload === null || payload === void 0 ? void 0 : payload.users) !== null && _d !== void 0 ? _d : [],
+        files: (_e = payload === null || payload === void 0 ? void 0 : payload.files) !== null && _e !== void 0 ? _e : [],
+        communityUsers: (_f = payload === null || payload === void 0 ? void 0 : payload.communityUsers) !== null && _f !== void 0 ? _f : [],
+    };
+    // There is no `comment.declined` event: the existing delete path drops the comment from every
+    // collection and the review queue, and moves no count because a pending comment was never counted.
+    const data = prepareCommentPayload(prepareMembershipPayload(declined, 'communityUsers'));
+    const rejected = data.comments.find(comment => comment.commentId === commentId);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache)
+        ingestInCache(data, { cachedAt });
+    unlinkCommentFromParent(rejected);
+    releasePendingAuthoredComment(rejected);
+    fireEvent('comment.deleted', declined);
+    return {
+        data: LinkedObject.comment(rejected),
+        cachedAt,
+    };
+};
+/* end_public_function */
+
 /* begin_public_function
   id: comment.flag
 */
@@ -26176,6 +27183,7 @@ const isCommentFlaggedByMe = async (commentId) => {
 /* end_public_function */
 
 const getComment$1 = async (commentId) => {
+    var _a;
     const client = getActiveClient();
     client.log('comment/getComment', commentId);
     isInTombstone('comment', commentId);
@@ -26186,7 +27194,11 @@ const getComment$1 = async (commentId) => {
         data = response.data;
     }
     catch (error) {
-        if (checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
+        // A pending comment answers 404 to anyone but its author and reviewers. That is a
+        // visibility answer, not a deletion — never tombstone a comment known to be pending.
+        const cached = (_a = pullFromCache(['comment', 'get', commentId])) === null || _a === void 0 ? void 0 : _a.data;
+        const isKnownPending = !!cached && isCommentPending(cached);
+        if (!isKnownPending && checkIfShouldGoesToTombstone(error === null || error === void 0 ? void 0 : error.code)) {
             pushToTombstone('comment', commentId);
         }
         throw error;
@@ -26313,6 +27325,7 @@ const onLocalCommentReactionRemoved = (callback) => {
  */
 const getComment = (commentId, callback) => {
     return liveObject(commentId, callback, 'commentId', getComment$1, [
+        onCommentApproved,
         onCommentDeleteLocal,
         onCommentDeleted,
         onCommentFlagged,
@@ -26326,28 +27339,31 @@ const getComment = (commentId, callback) => {
 };
 /* end_public_function */
 
-class CommentPaginationController extends PaginationController {
-    async getRequest(queryParams, token) {
-        var _a;
-        const { pageSize, limit, includeDeleted } = queryParams, params = __rest(queryParams, ["pageSize", "limit", "includeDeleted"]);
-        const effectiveLimit = (_a = pageSize !== null && pageSize !== void 0 ? pageSize : limit) !== null && _a !== void 0 ? _a : COLLECTION_DEFAULT_PAGINATION_LIMIT;
-        const baseOptions = {
-            type: params.sortBy || queryParams.limit || queryParams.pageSize ? 'pagination' : undefined,
-        };
-        const options = token
-            ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { pageSize: effectiveLimit, limit: effectiveLimit });
-        const { data: queryResponse } = await this.http.get(`/api/v3/comments`, {
-            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), options }),
-        });
-        return queryResponse;
-    }
-}
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+const onCommentCreatedLocal = (callback) => {
+    return createLocalCommentEventSubscriber('local.comment.created', callback);
+};
 
 var EnumCommentActions;
 (function (EnumCommentActions) {
     EnumCommentActions["OnCommentCreated"] = "onCommentCreated";
     EnumCommentActions["OnCommentUpdated"] = "onCommentUpdated";
     EnumCommentActions["OnCommentDeleted"] = "onCommentDeleted";
+    EnumCommentActions["OnCommentApproved"] = "onCommentApproved";
     EnumCommentActions["OnCommentFlagged"] = "onCommentFlagged";
     EnumCommentActions["OnCommentUnflagged"] = "onCommentUnflagged";
     EnumCommentActions["OnCommentReactionAdded"] = "onCommentReactionAdded";
@@ -26370,15 +27386,17 @@ class CommentQueryStreamController extends QueryStreamController {
     }
     appendToQueryStream(response, direction, refresh = false) {
         var _a, _b;
+        // The public list is approved-only even when the server widens the read for a reviewer
+        const commentIds = response.comments.filter(isCommentApproved).map(getResolver('comment'));
         if (refresh) {
             pushToCache(this.cacheKey, {
-                data: response.comments.map(getResolver('comment')),
+                data: commentIds,
             });
         }
         else {
             const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
             const comments = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
-            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...comments, ...response.comments.map(getResolver('comment'))])] }));
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...comments, ...commentIds])] }));
         }
     }
     reactor(action) {
@@ -26397,8 +27415,19 @@ class CommentQueryStreamController extends QueryStreamController {
                 return;
             }
             if (action === EnumCommentActions.OnCommentCreated) {
+                // A pending comment reaches clients over realtime before anyone may see it: persist
+                // only, no insert and no emit. `comment.approved` is the reveal signal.
+                if (!isCommentApproved(comment))
+                    return;
+                collection.data = [...new Set([comment.commentId, ...collection.data])];
+            }
+            if (action === EnumCommentActions.OnCommentApproved) {
                 collection.data = [...new Set([comment.commentId, ...collection.data])];
             }
+            // An effective edit in a gated community returns the comment to review: it leaves the list
+            if (action === EnumCommentActions.OnCommentUpdated && isCommentPending(comment)) {
+                collection.data = collection.data.filter(commentId => commentId !== comment.commentId);
+            }
             pushToCache(this.cacheKey, collection);
             this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
         };
@@ -26408,24 +27437,22 @@ class CommentQueryStreamController extends QueryStreamController {
     }
 }
 
-/**
- * ```js
- * import { onCommentCreated } from '@amityco/ts-sdk'
- * const dispose = onCommentCreated(comment => {
- *   // ...
- * })
- * ```
- *
- * Fired when a {@link Amity.InternalComment} has been created
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Comment Events
- */
-const onCommentCreatedLocal = (callback) => {
-    return createLocalCommentEventSubscriber('local.comment.created', callback);
-};
+class CommentPaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        var _a;
+        const { pageSize, limit, includeDeleted } = queryParams, params = __rest(queryParams, ["pageSize", "limit", "includeDeleted"]);
+        const effectiveLimit = (_a = pageSize !== null && pageSize !== void 0 ? pageSize : limit) !== null && _a !== void 0 ? _a : COLLECTION_DEFAULT_PAGINATION_LIMIT;
+        const baseOptions = {
+            type: params.sortBy || queryParams.limit || queryParams.pageSize ? 'pagination' : undefined,
+        };
+        const options = token
+            ? Object.assign(Object.assign({}, baseOptions), { token }) : Object.assign(Object.assign({}, baseOptions), { pageSize: effectiveLimit, limit: effectiveLimit });
+        const { data: queryResponse } = await this.http.get(`/api/v3/comments`, {
+            params: Object.assign(Object.assign({}, params), { isDeleted: inferIsDeleted(includeDeleted), options }),
+        });
+        return queryResponse;
+    }
+}
 
 class CommentLiveCollectionController extends LiveCollectionController {
     constructor(query, callback) {
@@ -26461,6 +27488,7 @@ class CommentLiveCollectionController extends LiveCollectionController {
             { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
             { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
             { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
+            { fn: onCommentApproved, action: EnumCommentActions.OnCommentApproved },
             { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
             { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
             { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
@@ -26494,7 +27522,8 @@ class CommentLiveCollectionController extends LiveCollectionController {
         });
     }
     applyFilter(data) {
-        let comments = data;
+        // Approved-only, for every caller including the author of a pending comment
+        let comments = data.filter(isCommentApproved);
         if (!this.query.includeDeleted) {
             comments = filterByPropEquality(comments, 'isDeleted', false);
         }
@@ -26582,7 +27611,202 @@ const getComments = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$e = /*#__PURE__*/Object.freeze({
+class CommentReviewQueuePaginationController extends PaginationController {
+    async getRequest(queryParams, token) {
+        const { communityId, limit } = queryParams, params = __rest(queryParams, ["communityId", "limit"]);
+        // The route defaults to 10, not the SDK-wide 20, and rejects anything above 100
+        const effectiveLimit = Math.min(limit !== null && limit !== void 0 ? limit : COMMENT_REVIEW_QUEUE_DEFAULT_PAGINATION_SIZE, COMMENT_REVIEW_QUEUE_MAX_PAGINATION_SIZE);
+        // Token paging only. The route also accepts options[skip], but offset paging over a queue that
+        // drains from the front skips items, so the SDK never sends it.
+        const options = token ? { token } : { limit: effectiveLimit };
+        const { data: queryResponse } = await this.http.get(API_ENDPOINTS.commentReviewQueue(communityId), {
+            params: Object.assign(Object.assign({}, params), { options }),
+        });
+        return queryResponse;
+    }
+}
+
+class CommentReviewQueueQueryStreamController extends QueryStreamController {
+    constructor(query, cacheKey, notifyChange) {
+        super(query, cacheKey);
+        this.notifyChange = notifyChange;
+    }
+    async saveToMainDB(response) {
+        const processedPayload = prepareCommentPayload(response);
+        const client = getActiveClient();
+        const cachedAt = client.cache && Date.now();
+        if (client.cache) {
+            ingestInCache(processedPayload, { cachedAt });
+        }
+    }
+    appendToQueryStream(response, direction, refresh = false) {
+        var _a, _b;
+        // Server order is queue-entry order, oldest first. Keep it: later pages append, nothing
+        // re-sorts by createdAt (the two diverge on re-review).
+        const commentIds = response.comments.map(getResolver('comment'));
+        if (refresh) {
+            pushToCache(this.cacheKey, {
+                data: commentIds,
+            });
+        }
+        else {
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            const comments = (_b = collection === null || collection === void 0 ? void 0 : collection.data) !== null && _b !== void 0 ? _b : [];
+            pushToCache(this.cacheKey, Object.assign(Object.assign({}, collection), { data: [...new Set([...comments, ...commentIds])] }));
+        }
+    }
+    matchesQuery(comment) {
+        return (comment.targetType === 'community' &&
+            comment.targetId === this.query.communityId &&
+            (!this.query.postId || comment.referenceId === this.query.postId));
+    }
+    reactor(action) {
+        return (comment) => {
+            var _a;
+            const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+            if (!collection || !this.matchesQuery(comment))
+                return;
+            const isQueued = collection.data.includes(comment.commentId);
+            // A date-filtered queue is the server's to shape; live events only remove from it
+            const acceptsLiveInserts = !this.query.startDate && !this.query.endDate;
+            switch (action) {
+                case EnumCommentActions.OnCommentCreated:
+                case EnumCommentActions.OnCommentUpdated:
+                    if (isCommentPending(comment) && !comment.isDeleted) {
+                        if (isQueued || !acceptsLiveInserts)
+                            return;
+                        // Enters (or, after an edit, re-enters) the queue at the end
+                        collection.data = [...collection.data, comment.commentId];
+                    }
+                    else {
+                        if (!isQueued)
+                            return;
+                        collection.data = collection.data.filter(commentId => commentId !== comment.commentId);
+                    }
+                    break;
+                case EnumCommentActions.OnCommentApproved:
+                case EnumCommentActions.OnCommentDeleted:
+                    if (!isQueued)
+                        return;
+                    collection.data = collection.data.filter(commentId => commentId !== comment.commentId);
+                    break;
+                default:
+                    return;
+            }
+            pushToCache(this.cacheKey, collection);
+            this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+        };
+    }
+    subscribeRTE(createSubscriber) {
+        return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+    }
+}
+
+class CommentReviewQueueLiveCollectionController extends LiveCollectionController {
+    constructor(query, callback) {
+        const queryStreamId = hash__default["default"](query);
+        const cacheKey = ['commentReviewQueue', 'collection', queryStreamId];
+        const paginationController = new CommentReviewQueuePaginationController(query);
+        super(paginationController, queryStreamId, cacheKey, callback);
+        this.query = query;
+        this.queryStreamController = new CommentReviewQueueQueryStreamController(this.query, this.cacheKey, this.notifyChange.bind(this));
+        this.callback = callback.bind(this);
+        this.loadPage({ initial: true });
+    }
+    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(queryPayload) {
+        await this.queryStreamController.saveToMainDB(queryPayload);
+    }
+    persistQueryStream({ response, direction, refresh, }) {
+        this.queryStreamController.appendToQueryStream(response, direction, refresh);
+    }
+    startSubscription() {
+        // No `comment.declined` exists: a decline arrives as `comment.deleted`
+        return this.queryStreamController.subscribeRTE([
+            { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
+            { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
+            { fn: onCommentApproved, action: EnumCommentActions.OnCommentApproved },
+            { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
+            { fn: onCommentDeleteLocal, action: EnumCommentActions.OnCommentDeleted },
+        ]);
+    }
+    notifyChange({ origin, loading, error }) {
+        var _a;
+        // A caller who lost REVIEW_COMMUNITY_COMMENT must not keep reading stale pending content
+        if ((error === null || error === void 0 ? void 0 : error.code) === 400301 /* Amity.ServerError.PERMISSION_DENIED */) {
+            pushToCache(this.cacheKey, { data: [], params: {} });
+        }
+        const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+        if (!collection)
+            return;
+        const data = collection.data
+            .map(id => pullFromCache(['comment', 'get', id]))
+            .filter(isNonNullable)
+            .map(({ data }) => data)
+            .filter(comment => isCommentPending(comment) && !comment.isDeleted)
+            .map(LinkedObject.comment);
+        if (!this.shouldNotify(data) && origin === 'event')
+            return;
+        this.callback({
+            onNextPage: () => this.loadPage({ direction: "next" /* Amity.LiveCollectionPageDirection.NEXT */ }),
+            data,
+            hasNextPage: !!this.paginationController.getNextToken(),
+            loading,
+            error,
+        });
+    }
+}
+
+/* begin_public_function
+  id: comment.review_queue
+*/
+/**
+ * ```js
+ * import { CommentRepository } from '@amityco/ts-sdk'
+ *
+ * const unsub = CommentRepository.getCommentReviewQueue(
+ *   { communityId: 'communityId' },
+ *   ({ data: comments, hasNextPage, onNextPage }) => {
+ *     // every comment is awaiting review
+ *   },
+ * )
+ * ```
+ *
+ * Observe the {@link Amity.Comment} list awaiting moderator review in a community, oldest first
+ *
+ * @param params the community to read the queue of, optionally narrowed to one post and a date range
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the queue
+ *
+ * @category Comments Live Collection
+ */
+const getCommentReviewQueue = (params, callback) => {
+    const { log, cache } = getActiveClient();
+    if (!cache)
+        console.log(ENABLE_CACHE_MESSAGE);
+    const timestamp = Date.now();
+    log(`getCommentReviewQueue(tmpid: ${timestamp}) > listen`);
+    const commentReviewQueueLiveCollection = new CommentReviewQueueLiveCollectionController(params, callback);
+    const disposers = commentReviewQueueLiveCollection.startSubscription();
+    const cacheKey = commentReviewQueueLiveCollection.getCacheKey();
+    disposers.push(() => dropFromCache(cacheKey));
+    return () => {
+        log(`getCommentReviewQueue(tmpid: ${timestamp}) > dispose`);
+        disposers.forEach(fn => fn());
+    };
+};
+/* end_public_function */
+
+var index$f = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getCommentByIds: getCommentByIds,
     createComment: createComment,
@@ -26590,18 +27814,22 @@ var index$e = /*#__PURE__*/Object.freeze({
     deleteComment: deleteComment,
     softDeleteComment: softDeleteComment,
     hardDeleteComment: hardDeleteComment,
+    approveComment: approveComment,
+    declineComment: declineComment,
     flagComment: flagComment,
     unflagComment: unflagComment,
     isCommentFlaggedByMe: isCommentFlaggedByMe,
     onCommentCreated: onCommentCreated,
     onCommentUpdated: onCommentUpdated,
     onCommentDeleted: onCommentDeleted,
+    onCommentApproved: onCommentApproved,
     onCommentFlagged: onCommentFlagged,
     onCommentUnflagged: onCommentUnflagged,
     onCommentReactionAdded: onCommentReactionAdded,
     onCommentReactionRemoved: onCommentReactionRemoved,
     getComment: getComment,
-    getComments: getComments
+    getComments: getComments,
+    getCommentReviewQueue: getCommentReviewQueue
 });
 
 /**
@@ -27851,7 +29079,7 @@ const getForYouFeed = (callback) => {
 };
 /* end_public_function */
 
-var index$d = /*#__PURE__*/Object.freeze({
+var index$e = /*#__PURE__*/Object.freeze({
     __proto__: null,
     queryGlobalFeed: queryGlobalFeed,
     getCustomRankingGlobalFeed: getCustomRankingGlobalFeed,
@@ -30996,7 +32224,7 @@ const getRooms = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$c = /*#__PURE__*/Object.freeze({
+var index$d = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createRoom: createRoom,
     updateRoom: updateRoom,
@@ -31295,7 +32523,7 @@ const getCommunityLiveRoomPosts = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index$b = /*#__PURE__*/Object.freeze({
+var index$c = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getPostByIds: getPostByIds,
     createPost: createPost,
@@ -31910,7 +33138,7 @@ const getStreams = (params, callback, config) => {
     };
 };
 
-var index$a = /*#__PURE__*/Object.freeze({
+var index$b = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createStream: createStream,
     updateStream: updateStream,
@@ -32213,7 +33441,7 @@ const stopHeartbeat = (roomId) => {
 };
 /* end_public_function */
 
-var index$9 = /*#__PURE__*/Object.freeze({
+var index$a = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getRoomOnlineUsers: getRoomOnlineUsers,
     getRoomUserCount: getRoomUserCount,
@@ -32524,7 +33752,7 @@ const getPoll = (pollId, callback) => {
 };
 /* end_public_function */
 
-var index$8 = /*#__PURE__*/Object.freeze({
+var index$9 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createPoll: createPoll,
     closePoll: closePoll,
@@ -32828,7 +34056,7 @@ const getPlayer = async (parameters) => {
     return video;
 };
 
-var index$7 = /*#__PURE__*/Object.freeze({
+var index$8 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getPlayer: getPlayer
 });
@@ -34001,7 +35229,7 @@ const getGlobalStoryTargets = (params, callback, config) => {
     };
 };
 
-var index$6 = /*#__PURE__*/Object.freeze({
+var index$7 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createImageStory: createImageStory,
     createVideoStory: createVideoStory,
@@ -34038,7 +35266,7 @@ const getNetworkAds = async () => {
     };
 };
 
-var index$5 = /*#__PURE__*/Object.freeze({
+var index$6 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getNetworkAds: getNetworkAds
 });
@@ -34429,7 +35657,7 @@ const markTraySeen = async (lastSeenAt) => {
 };
 /* end_public_function */
 
-var index$4 = /*#__PURE__*/Object.freeze({
+var index$5 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getNotificationTraySeen: getNotificationTraySeen,
     getNotificationTrayItems: getNotificationTrayItems,
@@ -34731,7 +35959,7 @@ const getInvitations = (params, callback) => {
     };
 };
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$4 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     cancelInvitation: cancelInvitation,
     onLocalInvitationCreated: onLocalInvitationCreated,
@@ -34880,7 +36108,7 @@ const getReactions = (postId, callback) => {
     };
 };
 
-var index$2 = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createReaction: createReaction,
     onLiveReactionCreated: onLiveReactionCreated,
@@ -35363,7 +36591,7 @@ const getMyEvents = (params, callback, config) => {
     };
 };
 
-var index$1 = /*#__PURE__*/Object.freeze({
+var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     createEvent: createEvent,
     updateEvent: updateEvent,
@@ -35590,12 +36818,36 @@ const searchProducts = (params, callback, config) => {
 };
 /* end_public_function */
 
-var index = /*#__PURE__*/Object.freeze({
+var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getProduct: getProduct,
     searchProducts: searchProducts
 });
 
+const getPool = async (topicId, limit) => {
+    const client = getActiveClient();
+    if (!topicId)
+        throw new ASCError('topicId must not be empty', 800110 /* Amity.ClientError.INVALID_PARAMETERS */, "error" /* Amity.ErrorLevel.ERROR */);
+    if (limit !== undefined && (limit < 1 || limit > 100))
+        throw new ASCError('limit must be between 1 and 100', 800110 /* Amity.ClientError.INVALID_PARAMETERS */, "error" /* Amity.ErrorLevel.ERROR */);
+    const { data } = await client.http.get('/api/v5/curated-content/pool', { params: { topicId, limit } });
+    const { topic } = data, payload = __rest(data, ["topic"]);
+    const processedPayload = preparePostPayload(payload);
+    const cachedAt = client.cache && Date.now();
+    if (client.cache) {
+        ingestInCache(processedPayload, { cachedAt });
+    }
+    return {
+        topic: LinkedObject.curatedContentTopic(topic),
+        posts: processedPayload.posts.map(LinkedObject.post),
+    };
+};
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getPool: getPool
+});
+
 /**
  * Helper class for managing product tags per media attachment.
  *
@@ -35644,39 +36896,40 @@ class AmityAttachmentProductTags {
 }
 
 exports.API_REGIONS = API_REGIONS;
-exports.AdRepository = index$5;
+exports.AdRepository = index$6;
 exports.AmityAttachmentProductTags = AmityAttachmentProductTags;
-exports.CategoryRepository = index$f;
-exports.ChannelRepository = index$j;
-exports.Client = index$s;
-exports.CommentRepository = index$e;
+exports.CategoryRepository = index$g;
+exports.ChannelRepository = index$k;
+exports.Client = index$t;
+exports.CommentRepository = index$f;
 exports.CommunityPostSettingMaps = CommunityPostSettingMaps;
 exports.CommunityPostSettings = CommunityPostSettings;
-exports.CommunityRepository = index$g;
+exports.CommunityRepository = index$h;
 exports.ContentFeedType = ContentFeedType;
+exports.CuratedContentRepository = index;
 exports.DefaultCommunityPostSetting = DefaultCommunityPostSetting;
-exports.EventRepository = index$1;
-exports.FeedRepository = index$d;
-exports.FileRepository = index$p;
+exports.EventRepository = index$2;
+exports.FeedRepository = index$e;
+exports.FileRepository = index$q;
 exports.FileType = FileType;
 exports.GET_WATCHER_URLS = GET_WATCHER_URLS;
-exports.InvitationRepository = index$3;
-exports.LiveReactionRepository = index$2;
-exports.LiveStreamPlayer = index$7;
+exports.InvitationRepository = index$4;
+exports.LiveReactionRepository = index$3;
+exports.LiveStreamPlayer = index$8;
 exports.MessageContentType = MessageContentType;
-exports.MessageRepository = index$n;
-exports.PollRepository = index$8;
+exports.MessageRepository = index$o;
+exports.PollRepository = index$9;
 exports.PostContentType = PostContentType;
-exports.PostRepository = index$b;
+exports.PostRepository = index$c;
 exports.PostStructureType = PostStructureType;
-exports.ProductRepository = index;
-exports.ReactionRepository = index$o;
-exports.RoomPresenceRepository = index$9;
-exports.RoomRepository = index$c;
-exports.StoryRepository = index$6;
-exports.StreamRepository = index$a;
-exports.SubChannelRepository = index$m;
-exports.UserRepository = index$q;
+exports.ProductRepository = index$1;
+exports.ReactionRepository = index$p;
+exports.RoomPresenceRepository = index$a;
+exports.RoomRepository = index$d;
+exports.StoryRepository = index$7;
+exports.StreamRepository = index$b;
+exports.SubChannelRepository = index$n;
+exports.UserRepository = index$r;
 exports.VERSION = VERSION;
 exports.VideoResolution = VideoResolution;
 exports.VideoSize = VideoSize;
@@ -35738,7 +36991,7 @@ exports.isPaged = isPaged;
 exports.isReportedByMe = isReportedByMe;
 exports.isSkip = isSkip;
 exports.mergeInCache = mergeInCache;
-exports.notificationTray = index$4;
+exports.notificationTray = index$5;
 exports.onChannelMarkerFetched = onChannelMarkerFetched;
 exports.onFeedMarkerFetched = onFeedMarkerFetched;
 exports.onFeedMarkerUpdated = onFeedMarkerUpdated;