@antzsoft/chat-core 1.4.6 → 1.4.8

package/dist/index.cjs

@@ -35,11 +35,37 @@ var chat_store_exports = {};
 __export(chat_store_exports, {
   useChatStore: () => useChatStore
 });
-var import_zustand2, useChatStore;
+function clearTypingExpiry(conversationId, userId) {
+  const key = typingKey(conversationId, userId);
+  const timer = _typingExpiryTimers.get(key);
+  if (timer) {
+    clearTimeout(timer);
+    _typingExpiryTimers.delete(key);
+  }
+}
+function clearAllTypingExpiry() {
+  _typingExpiryTimers.forEach((timer) => clearTimeout(timer));
+  _typingExpiryTimers.clear();
+}
+function scheduleTypingExpiry(conversationId, userId) {
+  const key = typingKey(conversationId, userId);
+  const existing = _typingExpiryTimers.get(key);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(() => {
+    _typingExpiryTimers.delete(key);
+    useChatStore.getState().removeTypingUser(conversationId, userId);
+  }, TYPING_EXPIRY_MS);
+  timer.unref?.();
+  _typingExpiryTimers.set(key, timer);
+}
+var import_zustand2, TYPING_EXPIRY_MS, _typingExpiryTimers, typingKey, useChatStore;
 var init_chat_store = __esm({
   "src/stores/chat.store.ts"() {
     "use strict";
     import_zustand2 = require("zustand");
+    TYPING_EXPIRY_MS = 6e3;
+    _typingExpiryTimers = /* @__PURE__ */ new Map();
+    typingKey = (conversationId, userId) => `${conversationId}\0${userId}`;
     useChatStore = (0, import_zustand2.create)((set) => ({
       activeConversationId: null,
       pendingTarget: null,
@@ -56,19 +82,40 @@ var init_chat_store = __esm({
       messageInfoId: null,
       setActiveConversation: (id) => set({ activeConversationId: id, replyingTo: null, editingMessage: null, forwardingMessage: null }),
       setPendingTarget: (target) => set({ pendingTarget: target }),
+      // Each typing user carries a self-expiring timer, so an indicator can never
+      // outlive the evidence for it. Previously the ONLY things that cleared an
+      // indicator were an explicit isTyping:false from the sender and a local
+      // socket disconnect — so any lost false edge left "is typing…" on screen
+      // indefinitely. That is reachable in normal use: a sender whose tab is killed
+      // while their other devices stay connected never triggers the server's
+      // disconnect cleanup (it only fires when the user's LAST socket goes), and
+      // the false edge is fire-and-forget so it is never retried.
+      //
+      // The timer is the authority on liveness; the sender's false edge is now just
+      // a fast path. TYPING_EXPIRY_MS must exceed chat-core's outbound throttle
+      // window (3s) by enough that a still-typing peer always re-asserts before it
+      // fires, otherwise indicators would visibly flicker mid-typing.
       addTypingUser: (conversationId, user) => set((state) => {
+        scheduleTypingExpiry(conversationId, user.userId);
         const existing = state.typingUsers[conversationId] ?? [];
         const deduped = existing.filter((u) => u.userId !== user.userId);
         return { typingUsers: { ...state.typingUsers, [conversationId]: [...deduped, user] } };
       }),
-      removeTypingUser: (conversationId, userId) => set((state) => ({
-        typingUsers: {
-          ...state.typingUsers,
-          [conversationId]: (state.typingUsers[conversationId] ?? []).filter(
-            (u) => u.userId !== userId
-          )
-        }
-      })),
+      removeTypingUser: (conversationId, userId) => set((state) => {
+        clearTypingExpiry(conversationId, userId);
+        const existing = state.typingUsers[conversationId];
+        if (!existing || !existing.some((u) => u.userId === userId)) return state;
+        return {
+          typingUsers: {
+            ...state.typingUsers,
+            [conversationId]: existing.filter((u) => u.userId !== userId)
+          }
+        };
+      }),
+      clearTypingUsers: () => {
+        clearAllTypingExpiry();
+        set({ typingUsers: {} });
+      },
       setUserOnline: (userId) => set((state) => ({
         onlineUsers: state.onlineUsers.includes(userId) ? state.onlineUsers : [...state.onlineUsers, userId]
       })),
@@ -111,6 +158,7 @@ __export(src_exports, {
   HIGHLY_FORWARDED_DEPTH_THRESHOLD: () => HIGHLY_FORWARDED_DEPTH_THRESHOLD,
   MAX_FORWARD_TARGETS: () => MAX_FORWARD_TARGETS,
   MENTION_ALL_ID: () => MENTION_ALL_ID,
+  TRANSIT_OPTIONAL_HEADER: () => TRANSIT_OPTIONAL_HEADER,
   TransitRateLimitedError: () => TransitRateLimitedError,
   appConfigApi: () => appConfigApi,
   authApi: () => authApi,
@@ -147,9 +195,11 @@ __export(src_exports, {
   readRetryAfterMs: () => readRetryAfterMs,
   reconnectSocket: () => reconnectSocket,
   refreshSocketAuth: () => refreshSocketAuth,
+  registerTeardownHook: () => registerTeardownHook,
   renderMentionParts: () => renderMentionParts,
   resetAuthStore: () => resetAuthStore,
   resetTrackedRooms: () => resetTrackedRooms,
+  resetTypingThrottle: () => resetTypingThrottle,
   resolveConfig: () => resolveConfig,
   resolveSystemMessageText: () => resolveSystemMessageText,
   setApiClientInstance: () => setApiClientInstance,
@@ -776,8 +826,9 @@ function ensureRestTransitHandshake() {
           waitMs = Math.min(500 * 2 ** failures, 8e3);
         } catch (err) {
           if (err instanceof TransitRateLimitedError) {
-            const blind = Math.min(15e3 * 2 ** rateLimitHits, 6e4);
-            waitMs = err.retryAfterMs != null ? Math.min(Math.max(err.retryAfterMs, 1e3), 6e4) : blind;
+            const ceiling = Math.min(6e4, TRANSIT_GATE_MAX_WAIT_MS);
+            const blind = Math.min(15e3 * 2 ** rateLimitHits, ceiling);
+            waitMs = err.retryAfterMs != null ? Math.min(Math.max(err.retryAfterMs, 1e3), ceiling) : blind;
             rateLimitHits++;
             console.warn(
               `[AntzChat] transit handshake rate-limited (429) \u2014 retrying in ${Math.round(waitMs / 1e3)}s${err.retryAfterMs != null ? " (per Retry-After)" : ""}.`
@@ -797,6 +848,12 @@ function ensureRestTransitHandshake() {
     }
   })();
 }
+var TRANSIT_OPTIONAL_HEADER = "x-antz-transit-optional";
+function isTransitOptional(req) {
+  const present = req.headers?.[TRANSIT_OPTIONAL_HEADER] != null;
+  if (present) delete req.headers[TRANSIT_OPTIONAL_HEADER];
+  return present;
+}
 function initApiClient(config, tokenStore) {
   _config = config;
   _tokenStore = tokenStore;
@@ -818,7 +875,7 @@ function initApiClient(config, tokenStore) {
       else if (_config.avatar.url) req.headers["x-avatar-url"] = _config.avatar.url;
       _avatarSent = true;
     }
-    if (_config?.transitEncryption) {
+    if (_config?.transitEncryption && !isTransitOptional(req)) {
       if (!getTransitSession()) ensureRestTransitHandshake();
       const ready = await awaitTransitReadyOr(TRANSIT_GATE_MAX_WAIT_MS);
       if (!ready) {
@@ -926,6 +983,7 @@ function getApiClient() {
 }
 
 // src/api/auth.ts
+var teardownRequest = { headers: { [TRANSIT_OPTIONAL_HEADER]: "1" } };
 var authApi = {
   async login(credentials) {
     const { data } = await getApiClient().post("/auth/login", credentials);
@@ -939,11 +997,22 @@ var authApi = {
     const { data } = await getApiClient().post("/auth/refresh", { refreshToken });
     return data;
   },
+  /**
+   * Ends the session. Never blocks on the transit handshake: logout has to work
+   * on a degraded channel, which is exactly when it matters most.
+   *
+   * The refreshToken is dropped when no transit session exists, so it is never
+   * sent in the clear. Losing it costs nothing meaningful — the server revokes
+   * against the JWT's own user id either way; passing it only lets the server
+   * target that one refresh token instead of the caller's session set.
+   */
   async logout(refreshToken) {
-    await getApiClient().post("/auth/logout", refreshToken ? { refreshToken } : {});
+    const encrypted = getTransitSession() != null;
+    const body = refreshToken && encrypted ? { refreshToken } : {};
+    await getApiClient().post("/auth/logout", body, teardownRequest);
   },
   async logoutAll() {
-    await getApiClient().post("/auth/logout-all");
+    await getApiClient().post("/auth/logout-all", {}, teardownRequest);
   },
   async getMe() {
     const { data } = await getApiClient().get("/users/me");
@@ -1237,6 +1306,19 @@ function secureOn(socket, event, handler) {
     handler(raw);
   });
 }
+var _teardownHooks = /* @__PURE__ */ new Set();
+function registerTeardownHook(hook) {
+  _teardownHooks.add(hook);
+  return () => _teardownHooks.delete(hook);
+}
+function runTeardownHooks() {
+  _teardownHooks.forEach((hook) => {
+    try {
+      hook();
+    } catch {
+    }
+  });
+}
 var _joinedRooms = /* @__PURE__ */ new Set();
 function trackRoomJoin(conversationId) {
   _joinedRooms.add(conversationId);
@@ -1432,6 +1514,10 @@ function disconnectSocket() {
   }
   clearTransitSession();
   resetAlgoCache();
+  runTeardownHooks();
+  Promise.resolve().then(() => (init_chat_store(), chat_store_exports)).then(({ useChatStore: useChatStore2 }) => {
+    useChatStore2.getState().clearTypingUsers();
+  });
   _getToken = null;
   _userId = void 0;
   _tenantId = void 0;
@@ -1483,6 +1569,12 @@ var RECONNECT_WAIT_TIMEOUT = 15e3;
 var QUEUE_MAX_SIZE = 100;
 var QUEUE_ENTRY_TTL = 3e4;
 var sendQueues = /* @__PURE__ */ new Map();
+var TYPING_THROTTLE_MS = 3e3;
+var _lastTypingSentAt = /* @__PURE__ */ new Map();
+function resetTypingThrottle() {
+  _lastTypingSentAt.clear();
+}
+registerTeardownHook(resetTypingThrottle);
 var sendQueueRunning = /* @__PURE__ */ new Map();
 async function drainSendQueue(conversationId) {
   if (sendQueueRunning.get(conversationId)) return;
@@ -1613,8 +1705,40 @@ var socketEmit = {
     return withAck("unpin_message", { messageId });
   },
   // markRead and typing are best-effort — silently dropped if socket not ready
+  //
+  // Typing is additionally LEADING-THROTTLED here rather than in the UI layer,
+  // so every consumer (both UI SDKs and any host calling socketEmit directly)
+  // gets the same emit budget and none can bypass it.
+  //
+  // The composer calls this on EVERY keystroke. A 40-word message is ~200 calls
+  // of which exactly one carries information: "this person started typing".
+  // Each one previously cost a round trip plus real server work, making typing
+  // the single most expensive event in the system per unit of user value.
+  //
+  // Shape of the throttle:
+  //   isTyping:true  — passed through at most once per TYPING_THROTTLE_MS per
+  //                    conversation. A continuous typist emits ~20/min instead
+  //                    of ~200/min.
+  //   isTyping:false — ALWAYS passed through, and resets the window. It is the
+  //                    edge that clears the indicator on every peer, it is
+  //                    already debounced by the composer, and dropping it is
+  //                    exactly the failure that leaves "is typing…" stuck.
+  //
+  // The server refreshes its typing key on each true edge (10s TTL) and
+  // receivers expire their own indicators after TYPING_EXPIRY_MS, both of which
+  // are comfortably longer than TYPING_THROTTLE_MS — so a throttled-away event
+  // never lets an indicator lapse mid-typing.
   typing(conversationId, isTyping) {
-    fireAndForget("typing", { conversationId, isTyping });
+    if (!isTyping) {
+      _lastTypingSentAt.delete(conversationId);
+      fireAndForget("typing", { conversationId, isTyping: false });
+      return;
+    }
+    const now = Date.now();
+    const last = _lastTypingSentAt.get(conversationId) ?? 0;
+    if (now - last < TYPING_THROTTLE_MS) return;
+    _lastTypingSentAt.set(conversationId, now);
+    fireAndForget("typing", { conversationId, isTyping: true });
   },
   markRead(conversationId, messageId) {
     fireAndForget("mark_read", { conversationId, ...messageId ? { messageId } : {} });
@@ -2142,7 +2266,9 @@ var devicesApi = {
    * Call this on logout so the user stops receiving push notifications on this device.
    */
   async remove(deviceId) {
-    await getApiClient().post(`/users/me/devices/${deviceId}/remove`);
+    await getApiClient().post(`/users/me/devices/${deviceId}/remove`, {}, {
+      headers: { [TRANSIT_OPTIONAL_HEADER]: "1" }
+    });
   }
 };
 
@@ -2332,6 +2458,7 @@ var AntzChatClient = class {
   HIGHLY_FORWARDED_DEPTH_THRESHOLD,
   MAX_FORWARD_TARGETS,
   MENTION_ALL_ID,
+  TRANSIT_OPTIONAL_HEADER,
   TransitRateLimitedError,
   appConfigApi,
   authApi,
@@ -2368,9 +2495,11 @@ var AntzChatClient = class {
   readRetryAfterMs,
   reconnectSocket,
   refreshSocketAuth,
+  registerTeardownHook,
   renderMentionParts,
   resetAuthStore,
   resetTrackedRooms,
+  resetTypingThrottle,
   resolveConfig,
   resolveSystemMessageText,
   setApiClientInstance,