@amityco/ts-sdk 7.29.1-e932a95f.0 → 7.30.0

package/dist/index.cjs.js

@@ -74,7 +74,7 @@ exports.UserProfileFieldEnum = void 0;
  * Selects which of the caller's reports `UserRepository.unflagUser` withdraws, sent as the
  * `reportType` query parameter. The four typed members are the backend `reportType` wire
  * values and match `UserReportTypeEnum`. `UNTYPED` selects the typeless (legacy) report,
- * which `isUserFlaggedByMe` returns as `reportType: null`; it is a selector only, never
+ * which `user.getUserFlagsByMe()` returns as `reportType: null`; it is a selector only, never
  * stored, and the flag endpoint refuses it.
  */
 exports.UserReportTypeFilterEnum = void 0;
@@ -359,8 +359,8 @@ exports.AmityLiveViewerCountMode = void 0;
 
 function getVersion() {
     try {
-        // the string ''v7.29.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
-        return 'v7.29.0-cjs';
+        // the string ''v7.30.0-cjs'' should be replaced by actual value by @rollup/plugin-replace
+        return 'v7.30.0-cjs';
     }
     catch (error) {
         return '__dev__';
@@ -1852,15 +1852,64 @@ async function modifyMqttConnection() {
     }
 }
 
+class SessionWatcher {
+    constructor() {
+        this._sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
+        this._listener = new Map();
+    }
+    onSessionStateChange(callback) {
+        this._listener.set(callback, callback);
+        return () => {
+            this._listener.delete(callback);
+        };
+    }
+    setSessionState(state, reason) {
+        if (this._sessionState === state)
+            return;
+        this._sessionState = state;
+        this._listener.forEach(cb => cb(state, reason));
+    }
+    destroy() {
+        this._listener.clear();
+    }
+}
+let instance$b;
+var SessionWatcher$1 = {
+    getInstance: () => {
+        if (!instance$b) {
+            instance$b = new SessionWatcher();
+        }
+        return instance$b;
+    },
+};
+
+/**
+ * ```js
+ * import { onSessionStateChange } from '@amityco/ts-sdk'
+ * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.Client} has a session state change
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Client Events
+ */
+const onSessionStateChange = (callback) => SessionWatcher$1.getInstance().onSessionStateChange(callback);
+
 /**
  * ```js
  * import { getFlagsByMe } from '~/userRepository/internalApi/getFlagsByMe'
  * const { isFlagByMe, flags } = await getFlagsByMe('userId')
  * ```
  *
- * The v4 read behind `user.getUserFlagsByMe()` and the deprecated
- * `UserRepository.isUserFlaggedByMe`: `GET /api/v4/users/:userId/isFlagByMe`, returned as
- * received. Nothing is filtered, cached or persisted, and `hashFlag` is not consulted here.
+ * The v4 read behind `user.getUserFlagsByMe()`, the background confirm of
+ * `user.isFlaggedByMe`, and the deprecated `UserRepository.isUserFlaggedByMe`:
+ * `GET /api/v4/users/:userId/isFlagByMe`, returned as received. Nothing is filtered, cached or
+ * persisted here, and `hashFlag` is not consulted.
  * This is the Web counterpart of iOS `ASCUserService.getFlagsByMe` and Android
  * `UserRepository.getFlagsByMe`, kept apart from the deprecated public function so the
  * user-object read does not change if that function ever does.
@@ -1921,35 +1970,72 @@ const locationsFor = (value, bits, hashes) => {
     }
     return locations;
 };
+/** Standard or URL-safe base64, padding optional. Anything else is not a filter we can read. */
+const BASE64 = /^[A-Za-z0-9+/_-]*={0,2}$/;
 /**
- * Whether `value` is probably in the filter. `false` is exact; `true` may be a false positive.
- * A missing filter (`null`, the server's value when nobody has flagged the object), a missing
- * value or a malformed filter all answer `false`.
+ * Whether `value` is probably in the filter. `false` is exact; `true` means "maybe", which may be
+ * a false positive. `null` (the server's value when nobody has flagged the object), a missing
+ * filter or a missing value answer `false`.
+ *
+ * A filter that cannot be read answers `true` ("maybe") and never throws, so the caller asks the
+ * server instead of trusting a "definitely not" it cannot back up (REQ-017): `bits` or `hashes`
+ * not a positive integer, a `hash` that is not base64, or a `hash` shorter than `ceil(bits / 8)`
+ * bytes.
  */
 const testBloomFilter = (hashFlag, value) => {
     if (!hashFlag || !value)
         return false;
     const { bits, hashes, hash } = hashFlag;
-    if (!(bits > 0) || !(hashes > 0) || typeof hash !== 'string')
-        return false;
+    if (!Number.isInteger(bits) || bits <= 0)
+        return true;
+    if (!Number.isInteger(hashes) || hashes <= 0)
+        return true;
+    if (typeof hash !== 'string' || !BASE64.test(hash))
+        return true;
     let buckets;
     try {
         buckets = jsBase64.toUint8Array(hash);
     }
     catch (_a) {
-        return false;
+        return true;
     }
+    if (buckets.length < Math.ceil(bits / 8))
+        return true;
     const locations = locationsFor(value, bits, hashes);
     for (let i = 0; i < locations.length; i += 1) {
         const index = Math.floor(locations[i] / 8);
         const bit = 1 << locations[i] % 8;
-        if (index >= buckets.length || (buckets[index] & bit) === 0)
+        if ((buckets[index] & bit) === 0)
             return false;
     }
     return true;
 };
 
-/** The current user's id, or `undefined` when there is no active client (the getter never throws). */
+/**
+ * Flag state of the current user on a target user, behind `Amity.User.isFlaggedByMe` and
+ * `Amity.User.getUserFlagsByMe()` (`user.check_flag_by_me` v1, REQ-011, REQ-012, REQ-016).
+ *
+ * `hashFlag` is a Bloom filter of reporter ids. "Definitely not" is exact. "Maybe" can be a
+ * false positive caused by other reporters, so the SDK confirms it with the server once per
+ * `hashFlag` value and records the answer in the cache under its own key, never on the user's
+ * cache row (REQ-015). Observers are told through `local.user.flagConfirmed` when a recorded
+ * answer changes what a user object would show.
+ *
+ * Not exported from the public API.
+ */
+/** Confirms for the same user are at least this far apart, as Android's `EkoFlag.expired`. */
+const FLAG_CONFIRM_INTERVAL = 1000;
+const cacheKey = (userId) => ['userFlagByMe', 'get', userId];
+const lastConfirmAt = new Map();
+/**
+ * Bumped by the current user's own flag and unflag. A confirm or exact read that started before
+ * one of them must not record its answer, because the write may have changed it while the
+ * `hashFlag` stayed the same.
+ */
+const generations = new Map();
+const generationOf = (userId) => { var _a; return (_a = generations.get(userId)) !== null && _a !== void 0 ? _a : 0; };
+const bumpGeneration = (userId) => generations.set(userId, generationOf(userId) + 1);
+/** The current user's id, or `undefined` when there is no active client. Never throws. */
 const currentUserId = () => {
     try {
         return getActiveClient().userId;
@@ -1958,43 +2044,223 @@ const currentUserId = () => {
         return undefined;
     }
 };
+const readRecord = (userId) => {
+    var _a;
+    try {
+        return (_a = pullFromCache(cacheKey(userId))) === null || _a === void 0 ? void 0 : _a.data;
+    }
+    catch (_b) {
+        return undefined;
+    }
+};
 /**
- * One `getUserFlagsByMe` closure per userId, remembering the newest user object linked for
- * that id. Live objects and collections compare snapshots with `isEqual`, which compares
- * functions by reference: a fresh closure on every linked object would make two reads of the
- * same user unequal and re-dispatch snapshots that did not change.
+ * The server's answer recorded for this user and this exact `hashFlag`, or `undefined` when there
+ * is none for the current user. Never throws.
  */
-const flagsByMeEntries = new Map();
+const readConfirmedFlag = (userId, hashFlag) => {
+    const me = currentUserId();
+    if (!me || !hashFlag || typeof hashFlag.hash !== 'string')
+        return undefined;
+    const record = readRecord(userId);
+    if (!record || record.reporterId !== me || record.hash !== hashFlag.hash)
+        return undefined;
+    return record.isFlagByMe;
+};
 /**
- * A Bloom filter has no false negatives, so `isFlaggedByMe === false` is exact and the request
- * can be skipped (REQ-012). The newest user object linked for that id is tested, as of its last
- * update. Without a filter to test, or without a current user, the server is asked.
+ * The v4 request in flight per user, with the generation it started in. A confirm and an exact
+ * read of the same user share one request; a request that started before the current user's own
+ * flag or unflag is not joined.
  */
-const knownNotFlaggedByMe = (userId) => {
+const inFlight = new Map();
+const requestFlagsByMe = (userId) => {
+    const generation = generationOf(userId);
+    const pending = inFlight.get(userId);
+    if (pending && pending.generation === generation)
+        return pending.promise;
+    const promise = getFlagsByMe(userId).finally(() => {
+        var _a;
+        if (((_a = inFlight.get(userId)) === null || _a === void 0 ? void 0 : _a.promise) === promise)
+            inFlight.delete(userId);
+    });
+    inFlight.set(userId, { generation, promise });
+    return promise;
+};
+const notifyObservers = (userId) => fireEvent('local.user.flagConfirmed', { userId });
+/**
+ * Records `isFlagByMe` for `hashFlag`. A "maybe" without a record shows `true`, so observers are
+ * told only when the shown value changes.
+ */
+const recordFlag = (userId, hashFlag, isFlagByMe) => {
     var _a;
     const me = currentUserId();
-    const user = (_a = flagsByMeEntries.get(userId)) === null || _a === void 0 ? void 0 : _a.latest;
-    if (!me || !user || user.hashFlag === undefined)
+    if (!me || typeof hashFlag.hash !== 'string')
+        return;
+    const shown = (_a = readConfirmedFlag(userId, hashFlag)) !== null && _a !== void 0 ? _a : true;
+    const record = { reporterId: me, hash: hashFlag.hash, isFlagByMe };
+    pushToCache(cacheKey(userId), record);
+    if (shown !== isFlagByMe)
+        notifyObservers(userId);
+};
+/**
+ * Starts one background confirm of a "maybe" (REQ-016): at most one in flight per user, and
+ * confirms for the same user at least {@link FLAG_CONFIRM_INTERVAL} apart. A failed confirm
+ * records nothing, surfaces no error, and a later read tries again.
+ */
+const confirmFlagByMe = (userId, hashFlag) => {
+    if (inFlight.has(userId))
+        return;
+    const now = Date.now();
+    const last = lastConfirmAt.get(userId);
+    if (last !== undefined && now - last < FLAG_CONFIRM_INTERVAL)
+        return;
+    const me = currentUserId();
+    const generation = generationOf(userId);
+    lastConfirmAt.set(userId, now);
+    requestFlagsByMe(userId)
+        .then(({ isFlagByMe }) => {
+        if (currentUserId() !== me || generationOf(userId) !== generation)
+            return;
+        recordFlag(userId, hashFlag, isFlagByMe);
+    })
+        .catch(() => {
+        // Not an answer: isFlaggedByMe stays true until a later read confirms again.
+    });
+};
+/**
+ * The value of `Amity.User.isFlaggedByMe` for a user object whose confirmed answer was captured
+ * (`confirmed`) when the object was linked, so a held object never changes (REQ-014).
+ *
+ * - No current user, `hashFlag: null` or a missing `hashFlag`, or "definitely not": `false`.
+ * - "Maybe" with a confirmed answer: that answer, no request.
+ * - "Maybe" without one: `true`, and one background confirm (REQ-016).
+ *
+ * The linked object declares this as a getter inside an object spread, which the build compiles
+ * to `Object.assign`, so it runs once when the user is linked and the object keeps that value.
+ */
+const isFlaggedByMeFor = (user, confirmed) => {
+    const me = currentUserId();
+    if (!me || !user.hashFlag || !testBloomFilter(user.hashFlag, me))
         return false;
-    return !testBloomFilter(user.hashFlag, me);
+    if (confirmed !== undefined)
+        return confirmed;
+    confirmFlagByMe(user.userId, user.hashFlag);
+    return true;
+};
+const NOT_FLAGGED = { isFlagByMe: false, flags: [] };
+const isNotOlder = (next, current) => {
+    var _a, _b;
+    const nextAt = Date.parse((_a = next.updatedAt) !== null && _a !== void 0 ? _a : '');
+    const currentAt = Date.parse((_b = current.updatedAt) !== null && _b !== void 0 ? _b : '');
+    return Number.isNaN(nextAt) || Number.isNaN(currentAt) || nextAt >= currentAt;
+};
+/**
+ * One `getUserFlagsByMe` closure per userId, remembering the newest user object linked for that
+ * id. Live objects and collections compare snapshots with `isEqual`, which compares functions by
+ * reference, so a fresh closure per linked object would re-dispatch unchanged snapshots
+ * (REQ-015). An older snapshot linked later does not replace a newer one.
+ */
+const flagsByMeEntries = new Map();
+/**
+ * `Amity.User.getUserFlagsByMe()` (REQ-012): `{ isFlagByMe: false, flags: [] }` with no request
+ * when the newest linked user says "not flagged", including a confirmed `false`. Otherwise the
+ * v4 read, returned as is; a confirm already in flight for the user is joined instead of sending
+ * a second request. Its `isFlagByMe` is recorded as the confirmed answer for the
+ * `hashFlag` it was read for; `flags[]` is never stored (REQ-009). A missing `hashFlag` is
+ * unknown, so the server is asked.
+ */
+const readFlagsByMe = async (userId) => {
+    var _a, _b;
+    const me = currentUserId();
+    const { hashFlag } = (_b = (_a = flagsByMeEntries.get(userId)) === null || _a === void 0 ? void 0 : _a.latest) !== null && _b !== void 0 ? _b : {};
+    if (me && hashFlag !== undefined) {
+        if (!hashFlag || !testBloomFilter(hashFlag, me))
+            return Object.assign(Object.assign({}, NOT_FLAGGED), { flags: [] });
+        if (readConfirmedFlag(userId, hashFlag) === false)
+            return Object.assign(Object.assign({}, NOT_FLAGGED), { flags: [] });
+    }
+    const generation = generationOf(userId);
+    const result = await requestFlagsByMe(userId);
+    if (hashFlag && currentUserId() === me && generationOf(userId) === generation) {
+        recordFlag(userId, hashFlag, result.isFlagByMe);
+    }
+    return result;
 };
 const getUserFlagsByMeFor = (user) => {
     let entry = flagsByMeEntries.get(user.userId);
     if (!entry) {
-        entry = {
-            latest: user,
-            getUserFlagsByMe: async () => {
-                if (knownNotFlaggedByMe(user.userId))
-                    return { isFlagByMe: false, flags: [] };
-                return getFlagsByMe(user.userId);
-            },
-        };
+        entry = { latest: user, getUserFlagsByMe: () => readFlagsByMe(user.userId) };
         flagsByMeEntries.set(user.userId, entry);
     }
-    entry.latest = user;
+    else if (isNotOlder(user, entry.latest)) {
+        entry.latest = user;
+    }
     return entry.getUserFlagsByMe;
 };
+/**
+ * The current user's own flag succeeded (REQ-016). Their report may leave `hashFlag` unchanged
+ * when other reporters had already set all of their bits, so the answer is known: record `true`
+ * for the `hashFlag` the response carries, or drop the answer when it carries none.
+ */
+const onFlaggedByMe = (user, userId) => {
+    bumpGeneration(userId);
+    if (user === null || user === void 0 ? void 0 : user.hashFlag) {
+        recordFlag(userId, user.hashFlag, true);
+        return;
+    }
+    const dropped = readRecord(userId);
+    dropFromCache(cacheKey(userId), true);
+    if ((dropped === null || dropped === void 0 ? void 0 : dropped.isFlagByMe) === false)
+        notifyObservers(userId);
+};
+/**
+ * The current user's own unflag succeeded (`user.unflag` REQ-010, REQ-016). A per-type unflag can
+ * leave other reports in place, so the answer is dropped, never set to `false`; the next "maybe"
+ * is confirmed again.
+ */
+const onUnflaggedByMe = (userId) => {
+    bumpGeneration(userId);
+    const dropped = readRecord(userId);
+    dropFromCache(cacheKey(userId), true);
+    if ((dropped === null || dropped === void 0 ? void 0 : dropped.isFlagByMe) === false)
+        notifyObservers(userId);
+};
+/** Forgets every in-memory trace of the current user's flag state. Records live in the cache. */
+const resetUserFlagByMe = () => {
+    flagsByMeEntries.clear();
+    inFlight.clear();
+    lastConfirmAt.clear();
+    generations.clear();
+};
+/**
+ * Registered through `setupLoginSubscriptions`. Every confirmed answer belongs to the current
+ * user, so the state is cleared on logout; the records themselves go with the cache, and each
+ * also carries the reporter's id.
+ */
+const userFlagByMeOnLoginHandler = () => {
+    const unsubscribe = onSessionStateChange(state => {
+        if (state === "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */ || state === "terminated" /* Amity.SessionStates.TERMINATED */) {
+            resetUserFlagByMe();
+        }
+    });
+    return () => {
+        unsubscribe();
+        resetUserFlagByMe();
+    };
+};
+/**
+ * Called with the cached user when a recorded answer changes what that user would show, so live
+ * objects and live collections deliver it again (REQ-016, delivery).
+ */
+const onUserFlagConfirmed = (callback) => createEventSubscriber(getActiveClient(), 'user/onUserFlagConfirmed', 'local.user.flagConfirmed', ({ userId }) => {
+    var _a;
+    const user = (_a = pullFromCache(['user', 'get', userId])) === null || _a === void 0 ? void 0 : _a.data;
+    if (user)
+        callback(user);
+});
+
 const userLinkedObject = (user) => {
+    // Captured now, so a user object the app holds never changes after a confirm (REQ-014).
+    const confirmedFlagByMe = readConfirmedFlag(user.userId, user.hashFlag);
     return Object.assign(Object.assign({}, user), { get avatar() {
             var _a;
             if (!user.avatarFileId)
@@ -2005,9 +2271,10 @@ const userLinkedObject = (user) => {
             return avatar;
         },
         get isFlaggedByMe() {
-            // Local Bloom-filter test on this object's own hashFlag: exact when false, "probably"
-            // when true, type-blind, no request. getUserFlagsByMe() gives the exact, per-type answer.
-            return testBloomFilter(user.hashFlag, currentUserId());
+            // Bloom test on this object's hashFlag: "definitely not" is exact and sends nothing.
+            // "Maybe" returns the answer confirmed for this hashFlag, or true while one background
+            // confirm runs (REQ-011, REQ-016). Never throws.
+            return isFlaggedByMeFor(user, confirmedFlagByMe);
         }, 
         /* begin_public_function
           id: user.get_flags_by_me
@@ -2279,13 +2546,13 @@ class NetworkActivitiesWatcher {
         this._listener.clear();
     }
 }
-let instance$b;
+let instance$a;
 var NetworkActivitiesWatcher$1 = {
     getInstance: () => {
-        if (!instance$b) {
-            instance$b = new NetworkActivitiesWatcher();
+        if (!instance$a) {
+            instance$a = new NetworkActivitiesWatcher();
         }
-        return instance$b;
+        return instance$a;
     },
 };
 
@@ -2469,54 +2736,6 @@ const createHttpTransport = (endpoint) => {
     return instance;
 };
 
-class SessionWatcher {
-    constructor() {
-        this._sessionState = "notLoggedIn" /* Amity.SessionStates.NOT_LOGGED_IN */;
-        this._listener = new Map();
-    }
-    onSessionStateChange(callback) {
-        this._listener.set(callback, callback);
-        return () => {
-            this._listener.delete(callback);
-        };
-    }
-    setSessionState(state, reason) {
-        if (this._sessionState === state)
-            return;
-        this._sessionState = state;
-        this._listener.forEach(cb => cb(state, reason));
-    }
-    destroy() {
-        this._listener.clear();
-    }
-}
-let instance$a;
-var SessionWatcher$1 = {
-    getInstance: () => {
-        if (!instance$a) {
-            instance$a = new SessionWatcher();
-        }
-        return instance$a;
-    },
-};
-
-/**
- * ```js
- * import { onSessionStateChange } from '@amityco/ts-sdk'
- * const dispose = onSessionStateChange((state: Amity.SessionStates) => {
- *   // ...
- * })
- * ```
- *
- * Fired when any {@link Amity.Client} has a session state change
- *
- * @param callback The function to call when the event was fired
- * @returns an {@link Amity.Unsubscriber} function to stop listening
- *
- * @category Client Events
- */
-const onSessionStateChange = (callback) => SessionWatcher$1.getInstance().onSessionStateChange(callback);
-
 const TOPICS = {
     [exports.AmityAutoSubscription.NETWORK]: [getNetworkTopic],
     [exports.AmityAutoSubscription.CHAT]: [
@@ -8584,7 +8803,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(), postCommentCountEngineOnLoginHandler(), channelActivityOnLoginHandler());
+    onChannelDeleted(removeChannelMarkerCache), onChannelMemberBanned(removeChannelMarkerCache), markReadEngineOnLoginHandler(), analyticsEngineOnLoginHandler(), objectResolverEngineOnLoginHandler(), reactionSyncEngineOnLoginHandler(), blockedUserSyncEngineOnLoginHandler(), blockingUserSyncEngineOnLoginHandler(), blockRealtimeOnLoginHandler(), resetAutoSubscriptionsOnLogout(), CursorController.clearOnLogout(), postCommentCountEngineOnLoginHandler(), channelActivityOnLoginHandler(), userFlagByMeOnLoginHandler());
     if (client.useLegacyUnreadCount) {
         subscriptions.push(readReceiptSyncEngineOnLoginHandler());
     }
@@ -13804,7 +14023,7 @@ const getWatchSessionStorage = () => {
     return storageInstance;
 };
 
-const privateKey = "MIIEpQIBAAKCAQEAwAEc/oZgYIvKSUG/C3mONYLR4ZPgAjMEX4bJ+xqqakUDRtqlNO+eZs2blQ1Ko0DBkqPExyQezvjibH5W2UZBV5RaBTlTcNVKTToMBEGesAfaEcM3qUyQHxdbFYZv6P4sb14dcwxTQ8usmaV8ooiR1Fcaso5ZWYcZ8Hb46FbQ7OoVumsBtPWwfZ4f003o5VCl6AIM6lcLv9UDLlFVYhE+PeXpRHtfWlGqxMvqC9oinlwhL6nWv6VjQXW4nhcib72dPBzfHT7k/PMKto2SxALYdb68ENiAGuJLWi3AUHSyYCJK2w7wIlWfJUAI0v26ub10IpExr6D5QuW2577jjP93iwIDAQABAoIBAFWfqXhwIIatkFY+9Z1+ZcbDQimgsmMIsUiQaX6Lk7e0cxOj6czDlxYtVtaPiNtow2pLkjNkjkCqiP7tEHnwdK9DvylZOTa2R15NJpK3WLcTqVIGhsn/FL5owfvFah6zSsmXZParZm5zY9NZE03ALZhOB9/cz0e3kf/EbpfeL2mW7MApyiUt5i09ycchroOpcWp73ipIxvgigtZyUGFmsQicWhUs28F0D7w4Qfk76yG3nqXeb+BAMhCaIaa/k/aAxhiZG/ygEQWQrcC8gfe+jyicMAQPDEVS9YuUMGsLjIjKuVLZzp2xirQnhc2i2zVNEIvG6soprPOBEMQugzrtX5ECgYEA3b7KAbBIbDl1e4ZSCWhHdHkiWVZHaopsR/LhqDDNhXjWjq3AesgV6k0j9EdziMn/HmmOso0bz99GTV3JZf4A9ztTLumJlkHbdVtlgOqSjrFLj12rH9KXTheyIhWSpUmm8+WB1xasFbqpvJaGo7F3pd2Fqj1XR4mp5BO7c/t7LJ0CgYEA3aouEzXQ9THRKYocdfY69EI1Il1t/d/RSqqd9BxEjxBgxkM13ZiYIn/R4WW/nCUrlmhxG44Aa2Gob4Ahfsui2xKTg/g/3Zk/rAxAEGkfOLGoenaJMD41fH4wUq3FRYwkvnaMb9Hd6f/TlBHslIRa2NN58bSBGJCyBP2b59+2+EcCgYEAixDVRXvV37GlYUOa/XVdosk5Zoe6oDGRuQm0xbNdoUBoZvDHDvme7ONWEiQha/8qtVsD+CyQ7awcPfb8kK9c0bBt+bTS6d4BkTcxkEkMgtrkBVR8Nqfu5jXsLH4VCv4G61zbMhZw8+ut+az5YX2yCN7Frj9sFlxapMRPQmzMEe0CgYEAumsAzM8ZqNv4mAK65Mnr0rhLj1cbxcKRdUYACOgtEFQpzxN/HZnTeFAe5nx3pI3uFlRHq3DFEYnT6dHMWaJQmAULYpVIwMi9L6gtyJ9fzoI6uqMtxRDMUqKdaSsTGOY/kJ6KhQ/unXi1K3XXjR+yd1+C0q+HUm1+CYxvrZYLfskCgYEArsEy+IQOiqniJ0NE2vVUF+UK/IRZaic9YKcpov5Ot7Vvzm/MnnW4N1ljVskocETBWMmPUvNSExVjPebi+rxd8fa5kY8BJScPTzMFbunZn/wjtGdcM10qdlVQ9doG61A/9P3ezFKCfS4AvF/H/59LcSx2Bh28fp3/efiVIOpVd4Y=";
+const privateKey = "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDHo80SecH7FuF2\nhFYnb+l26/VN8UMLXAQFLnxciNTEwkGVFMpdezlH8rU2HtUJL4RETogbAOLVY0XM\njs6sPn8G1nALmh9qeDpUtVqFOVtBHxEZ910TLOtQiunjqJKO5nWdqZ71EC3OFluR\niGQkO84BiIFbv37ub7xl3S8XarbtKoLcyVpkDHi+1wx1pgCAn6gtBUgckPL5NR8j\nLseabl3HAXQfhTCKo4tmOFM2Dxwl1IUMmIJrJg/aIU/U0tj/1Eoo7mG0JcNWX19l\nW3EecCbi0ncCJOrkUdwlBrcjaMayaX/ubEwyUeTGiLdyc4L3GRLHjyK8xgVNXRMH\nbZWJ2a5NAgMBAAECggEASxuE+35zTFO/XydKgmvIGcWL9FbgMlXb7Vcf0nBoG945\nbiz0NVc2paraIhJXc608xbYF3qLmtAE1MVBI0ORyRdBHNxY024l/6H6SH60Ed+uI\nM4ysp5ourY6Vj+DLwpdRiI9YDjqYAQDIUmhNxJP7XPhOMoZI6st+xZQBM34ic/bv\nAMSJm9OZphSp3+qXVkFZztr2mxD2EZSJJLYxi8BCdgM2qhazalbcJ6zDKHCZWVWm\n8RRxDGldyMb/237JxETzP40tAlzOZDmBAbUgEnurDJ93RVDIE3rbZUshwgeQd18a\nem096mWgvB1AIKYgsTAR3pw+V19YWAjq/glP6fz8wQKBgQD/oQq+ukKF0PRgBeM5\ngeTjSwsdGppQLmf5ndujvoiz/TpdjDEPu6R8kigQr1rG2t4K/yfdZoI8RdmJD1al\n3Q7N9hofooSy4rj6E3txzWZCHJjHad2cnCp/O26HiReGAl7wTcfTmNdiFHhZQzm5\nJBkvWAiwuvQMNfEbnXxw6/vIDwKBgQDH7fX8gsc77JLvAWgp1MaQN/sbqVb6JeT1\nFQfR8E/WFCSmzQBtNzd5KgYuCeelwr/8DyYytvN2BzCYZXp73gI1jF3YlW5jVn74\nOY6TwQ095digwo6Z0yuxopdIOApKgAkL9PRKgNrqAf3NAyMua6lOGifzjDojC3KU\nfylQmxMn4wKBgHp2B9O/H0dEBw5JQ8W0+JX6yWQz7mEjGiR2/1W+XXb8hQ1zr709\nw1r6Gb+EghRpnZ3fBpYGGbYOMFx8wKHM+N6qW3F0ReX8v2juFGE8aRSa5oYBrWzt\nU16Idjbv8hj84cZ1PJmdyvDtpYn9rpWHOZl4rxEbPvbqkIsOMyNVqdT5AoGAOSge\nmwIIU2le2FVeohbibXiToWTYKMuMmURZ5/r72AgKMmWJKbAPe+Q3wBG01/7FRBpQ\noU8Ma0HC8s6QJbliiEyIx9JwrJWd1vkdecBHONrtA4ibm/5zD2WcOllLF+FitLhi\n3qnX6+6F0IaFGFBPJrTzlv0P4dTz/OAdv52V7GECgYEA2TttOKBAqWllgOaZOkql\nLVMJVmgR7s6tLi1+cEP8ZcapV9aRbRzTAKXm4f8AEhtlG9F9kCOvHYCYGi6JaiWJ\nZkHjeex3T+eE6Di6y5Bm/Ift5jtVhJ4jCVwHOKTMej79NPUFTJfv8hCo29haBDv6\nRXFrv+T21KCcw8k3sJeJWWQ=\n-----END PRIVATE KEY-----";
 /*
  * The crypto algorithm used for importing key and signing string
  */
@@ -15630,8 +15849,11 @@ const flagUser = async (userId, options) => {
     if (client.cache) {
         ingestInCache(payload);
     }
+    const flagged = (_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0];
+    // The caller's own report may leave hashFlag unchanged; record that they flagged (REQ-016).
+    onFlaggedByMe(flagged, userId);
     fireEvent('user.flagged', data);
-    return userLinkedObject((_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0]);
+    return userLinkedObject(flagged);
 };
 /* end_public_function */
 
@@ -15651,8 +15873,11 @@ const submitUserReport = async (apiName, userId, body) => {
     if (client.cache) {
         ingestInCache(payload);
     }
+    const flagged = (_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0];
+    // The caller's own report may leave hashFlag unchanged; record that they flagged (REQ-016).
+    onFlaggedByMe(flagged, userId);
     fireEvent('user.flagged', data);
-    return userLinkedObject((_a = payload.users.find(user => user.userId === userId)) !== null && _a !== void 0 ? _a : payload.users[0]);
+    return userLinkedObject(flagged);
 };
 
 /** Maximum `comment` length, in string length units, after trimming. */
@@ -15831,14 +16056,15 @@ const flagUserBehavior = async (userId, options) => submitUserReport('flagUserBe
  * untouched. Withdrawing a report that does not exist succeeds and changes nothing.
  *
  * The returned user is persisted to the cache, so its `hashFlag` says whether the caller
- * still holds any report on the user. Do not flip a local "flagged by me" flag to `false`
- * after a per-type withdrawal; read the fresh user, or call `isUserFlaggedByMe` for the
- * remaining per-type state (`flags`).
+ * may still hold a report on the user. Do not flip a local "flagged by me" flag to `false`
+ * after a per-type withdrawal; observe the user and read `isFlaggedByMe`, or call
+ * `user.getUserFlagsByMe()` for the remaining per-type state (`flags`). The SDK drops the
+ * answer it confirmed for this user, so the next "maybe" is confirmed again.
  *
  * Sends `DELETE /api/v4/me/flags/:userId`, with `?reportType=<type>` when one is given.
  *
  * @param userId The ID of the user to unflag
- * @param options Optional; `reportType` selects a single report to withdraw. For a report that `isUserFlaggedByMe` lists with `reportType: null`, pass `UserReportTypeFilterEnum.UNTYPED`
+ * @param options Optional; `reportType` selects a single report to withdraw. For a report that `user.getUserFlagsByMe()` lists with `reportType: null`, pass `UserReportTypeFilterEnum.UNTYPED`
  * @returns `true` once the server has processed the withdrawal
  * @throws {ASCInvalidParameterError} `INVALID_PARAMETERS` when `reportType` is not a `UserReportTypeFilterEnum` value, before any request is made
  *
@@ -15857,6 +16083,8 @@ const unflagUser = async (userId, options) => {
     if (client.cache) {
         ingestInCache(payload);
     }
+    // Drop the confirmed answer; never set it to false: other reports may remain (REQ-010).
+    onUnflaggedByMe(userId);
     fireEvent('user.unflagged', data);
     return !!payload;
 };
@@ -15868,33 +16096,19 @@ const unflagUser = async (userId, options) => {
 /**
  * ```js
  * import { UserRepository } from '@amityco/ts-sdk'
- *
- * const { isFlagByMe, flags } = await UserRepository.isUserFlaggedByMe('userId')
- *
- * // Grey out the report options already used; null marks the typeless report.
- * const used = new Set(flags.map(flag => flag.reportType))
+ * const isFlagged = await UserRepository.isUserFlaggedByMe(userId)
  * ```
  *
- * Returns whether the caller has reported a user, with each of the caller's own reports
- * on that user, exactly as `GET /api/v4/users/:userId/isFlagByMe` answers. Each report
- * carries `reportType`, `reason`, `comment` and `createdAt`; a field the report does not
- * have is `null`. `reportType: null` is the typeless (legacy) report, which `unflagUser`
- * withdraws with `UserReportTypeFilterEnum.UNTYPED`. Only the caller's reports come back.
- *
- * This is the only source of per-type state. Nothing is filtered, cached or persisted:
- * the call reads the server every time and does not consult `hashFlag`, which is a
- * type-blind bloom filter. Call it again after a flag or unflag when the UI needs the
- * updated per-type state.
+ * Whether the current user has reported a user. Sends one request per call and caches
+ * nothing.
  *
- * Breaking change: earlier versions returned a boolean from the v3 endpoint, which the
- * backend has deprecated. Read `isFlagByMe` on the result for the same answer.
- *
- * @deprecated On an {@link Amity.User} you already hold, read `user.isFlaggedByMe` for a
- * request-free badge and call `user.getUserFlagsByMe()` for the reports; it skips the request
- * when the Bloom test says the user is not flagged. This function remains the underlying request.
+ * @deprecated Read `user.isFlaggedByMe` on an {@link Amity.User} for a yes/no hint that
+ * usually needs no request, and call `user.getUserFlagsByMe()` for the exact answer with the
+ * caller's reports by type. Observe the user with `UserRepository.getUser(userId, callback)`
+ * to follow a flag or unflag.
  *
  * @param userId The ID of the user to check
- * @returns the caller's {@link Amity.UserFlagByMe} on that user
+ * @returns `true` if the current user has reported the user, `false` if not
  *
  * @category Report API
  * @async
@@ -15902,7 +16116,8 @@ const unflagUser = async (userId, options) => {
 const isUserFlaggedByMe = async (userId) => {
     const client = getActiveClient();
     client.log('user/isUserFlaggedByMe', userId);
-    return getFlagsByMe(userId);
+    const { isFlagByMe } = await getFlagsByMe(userId);
+    return isFlagByMe;
 };
 /* end_public_function */
 
@@ -16141,7 +16356,7 @@ const getUser = (userId, callback) => {
     const reactor = (response) => {
         return callback(Object.assign(Object.assign({}, response), { data: response.data ? LinkedObject.user(response.data) : response.data }));
     };
-    return liveObject(userId, reactor, 'userId', getUser$1, [
+    const unsubscribeUser = liveObject(userId, reactor, 'userId', getUser$1, [
         onUserFetched,
         onUserUpdated,
         onUserDeleted$2,
@@ -16149,6 +16364,17 @@ const getUser = (userId, callback) => {
         onUserUnflagged,
         onUserFlagCleared,
     ]);
+    // A confirmed flag answer leaves the cached user row unchanged, so the live object's own
+    // dedupe would drop it. Deliver the re-linked user directly (user.check_flag_by_me REQ-016).
+    const unsubscribeFlag = onUserFlagConfirmed(user => {
+        if (user.userId !== userId)
+            return;
+        callback({ data: LinkedObject.user(user), loading: false, origin: 'event' });
+    });
+    return () => {
+        unsubscribeUser();
+        unsubscribeFlag();
+    };
 };
 /* end_public_function */
 
@@ -16246,13 +16472,24 @@ class UserLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
-            { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
-            { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
-            { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
-            { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
-        ]);
+        return [
+            ...this.queryStreamController.subscribeRTE([
+                { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
+                { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
+                { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
+                { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
+                { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
+            ]),
+            // A confirmed flag answer changes isFlaggedByMe on a listed user without changing its
+            // cache row (user.check_flag_by_me REQ-016). Re-link only collections that hold it.
+            onUserFlagConfirmed(user => {
+                var _a;
+                const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                if (!(collection === null || collection === void 0 ? void 0 : collection.data.includes(user.userId)))
+                    return;
+                this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+            }),
+        ];
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;
@@ -16804,13 +17041,24 @@ class SearchUserLiveCollectionController extends LiveCollectionController {
         this.queryStreamController.appendToQueryStream(response, direction, refresh);
     }
     startSubscription() {
-        return this.queryStreamController.subscribeRTE([
-            { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
-            { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
-            { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
-            { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
-            { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
-        ]);
+        return [
+            ...this.queryStreamController.subscribeRTE([
+                { fn: onUserDeleted$2, action: EnumUserActions.OnUserDeleted },
+                { fn: onUserUpdated, action: EnumUserActions.OnUserUpdated },
+                { fn: onUserFlagged, action: EnumUserActions.OnUserFlagged },
+                { fn: onUserUnflagged, action: EnumUserActions.OnUserUnflagged },
+                { fn: onUserFlagCleared, action: EnumUserActions.OnUserFlagCleared },
+            ]),
+            // A confirmed flag answer changes isFlaggedByMe on a listed user without changing its
+            // cache row (user.check_flag_by_me REQ-016). Re-link only collections that hold it.
+            onUserFlagConfirmed(user => {
+                var _a;
+                const collection = (_a = pullFromCache(this.cacheKey)) === null || _a === void 0 ? void 0 : _a.data;
+                if (!(collection === null || collection === void 0 ? void 0 : collection.data.includes(user.userId)))
+                    return;
+                this.notifyChange({ origin: "event" /* Amity.LiveDataOrigin.EVENT */, loading: false });
+            }),
+        ];
     }
     notifyChange({ origin, loading, error }) {
         var _a, _b;