@antzsoft/chat-core 1.4.6 → 1.4.7

package/README.md

@@ -2459,10 +2459,10 @@ All emit methods that have server responses use a 5-second ack timeout and retur
 | `removeReaction` | `(messageId: string, emoji: string) => Promise<unknown>` | Remove a reaction. Ack-based. |
 | `pinMessage` | `(messageId: string) => Promise<unknown>` | Pin a message. Ack-based. |
 | `unpinMessage` | `(messageId: string) => Promise<unknown>` | Unpin a message. Ack-based. |
-| `typing` | `(conversationId: string, isTyping: boolean) => void` | Broadcast typing status. Fire-and-forget. |
+| `typing` | `(conversationId: string, isTyping: boolean) => void` | Broadcast typing status. Fire-and-forget. **Leading-throttled since v1.4.7**: `true` emits at most once per 3s per conversation, `false` always emits and resets the window. Safe to call on every keystroke. |
 | `markRead` | `(conversationId: string, messageId?: string) => void` | Mark messages read. Fire-and-forget. |
 | `getOnlineUsers` | `(userIds: string[]) => Promise<string[]>` | Query which of the given user IDs are online. Returns the online subset. |
-| `getTypingUsers` | `(conversationId: string) => Promise<unknown>` | Fetch users currently typing in a conversation. Ack-based. |
+| `getTypingUsers` | `(conversationId: string) => Promise<unknown>` | Fetch users currently typing in a conversation. Ack-based. Not used by the shipped UI SDKs — useful if you want a client joining a room mid-typing to see the current state rather than waiting for the next event. |
 
 ```typescript
 // Join before sending
@@ -2475,7 +2475,9 @@ await socketEmit.sendMessage({
   tempId: crypto.randomUUID(),
 });
 
-// Typing indicator
+// Typing indicator — call `true` freely (per keystroke is fine); core
+// leading-throttles it to one emit per 3s per conversation. The `false`
+// edge always goes out, so the indicator clears promptly on every peer.
 socketEmit.typing('conv-abc', true);
 // ... user stops typing
 socketEmit.typing('conv-abc', false);
@@ -2647,7 +2649,7 @@ import { useChatStore } from '@antzsoft/chat-core';
 |---|---|---|
 | `activeConversationId` | `string \| null` | The currently open conversation. |
 | `pendingTarget` | `{ conversationId: string; messageId: string } \| null` | Scroll-to target for deep-linked messages. |
-| `typingUsers` | `Record<string, TypingUser[]>` | Map of conversationId → users currently typing. |
+| `typingUsers` | `Record<string, TypingUser[]>` | Map of conversationId → users currently typing. Each entry self-expires after 6s without a refreshing event (v1.4.7), so a lost `isTyping:false` can no longer leave an indicator stuck. Clear all with `clearTypingUsers()`. |
 | `onlineUsers` | `string[]` | Array of user IDs currently online. |
 | `lastRead` | `Record<string, LastReadEntry>` | Map of conversationId → `{ messageId, readAt }` — the current user's last-read pointer per conversation. Hydrated by `read_receipt` socket events automatically. |
 | `lastSeen` | `Record<string, string>` | Map of userId → ISO timestamp — each user's last-seen time. Hydrated by `user_offline` socket events automatically. |
@@ -3285,6 +3287,18 @@ document.querySelectorAll('[data-conv-id]').forEach((el) => {
 
 > **Full history lives in [CHANGELOG.md](CHANGELOG.md).** That file is the source of truth and covers every release. This section carries only the headline notes for recent versions; v1.4.2, v1.4.3 and v1.4.4 (message forwarding, per-attachment forwarding, and send/forward retry-safety) are documented there rather than duplicated here.
 
+### v1.4.7
+
+- **Changed: `socketEmit.typing` is leading-throttled — ~94.5% fewer typing emits.** The composer calls it per keystroke and every call used to become a wire emit: ~200 for a 40-word message, of which one carried information. Each cost a round trip plus two MongoDB queries server-side and, with transit on, one Redis lookup + one AES encryption *per recipient socket*. Now `isTyping:true` passes at most once per 3s per conversation, while `isTyping:false` always passes and resets the window. Measured: 201 emits → 11 for a 200-keystroke message.
+
+  **No integration changes required** — keep calling `startTyping()` per keystroke; the throttle is inside core. Do not add a second throttle in your own composer. Trade-off: a re-assert after a pause can lag up to 3s; typing *start* is still immediate.
+
+- **Fixed: typing indicators can no longer get stuck on screen.** The only things that cleared one were an explicit `isTyping:false` and a local socket disconnect, so any lost `false` edge left "X is typing…" up indefinitely — reachable when the sender's tab is killed while their other devices stay connected (the server's disconnect cleanup only fires on their *last* socket). `addTypingUser` now arms a per-user 6s expiry timer, re-armed by each refreshing event; 6s exceeds the 3s throttle window, so a still-typing peer always re-asserts before their indicator lapses.
+
+- **Added: `clearTypingUsers()`** on the chat store (drops all indicators + cancels timers), **`resetTypingThrottle()`**, and **`registerTeardownHook(hook)`**. All additive. `disconnectSocket()` wires the first two for you.
+
+- **Server-side, no SDK action needed:** chat-server now runs the typing path with **zero MongoDB queries**, broadcasts `typing_indicator` unencrypted as one adapter publish (metadata only — no message content), rate-limits it per user, and skips it in rooms above `TYPING_MAX_ROOM_SOCKETS` sockets (default 30). The plaintext switch is safe on **every already-deployed SDK version**: `secureOn()` decrypts only what matches `isTransitEnvelope()` (`{v:1, iv, tag, ct}`), so a plain payload passes through untouched. Deploy the server independently; clients upgrade when convenient.
+
 ### v1.4.5
 
 Published as `1.4.5`; built and reviewed internally as `1.4.7` (same code — there is no `1.4.6`, and no separate `1.4.7` will be published).

package/dist/chat.store-TA6G7PD6.js

@@ -0,0 +1,7 @@
+import {
+  useChatStore
+} from "./chunk-QHELYVNT.js";
+export {
+  useChatStore
+};
+//# sourceMappingURL=chat.store-TA6G7PD6.js.map

package/dist/chunk-QHELYVNT.js

@@ -0,0 +1,109 @@
+// src/stores/chat.store.ts
+import { create } from "zustand";
+var TYPING_EXPIRY_MS = 6e3;
+var _typingExpiryTimers = /* @__PURE__ */ new Map();
+var typingKey = (conversationId, userId) => `${conversationId}\0${userId}`;
+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 useChatStore = create((set) => ({
+  activeConversationId: null,
+  pendingTarget: null,
+  typingUsers: {},
+  onlineUsers: [],
+  lastRead: {},
+  lastSeen: {},
+  replyingTo: null,
+  editingMessage: null,
+  forwardingMessage: null,
+  isSidebarOpen: true,
+  isGroupInfoOpen: false,
+  isStarredPanelOpen: false,
+  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) => {
+    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]
+  })),
+  setUserOffline: (userId) => set((state) => ({ onlineUsers: state.onlineUsers.filter((id) => id !== userId) })),
+  setOnlineUsers: (userIds) => set({ onlineUsers: userIds }),
+  setLastRead: (conversationId, messageId, readAt) => set((state) => ({
+    lastRead: { ...state.lastRead, [conversationId]: { messageId, readAt } }
+  })),
+  setLastSeen: (userId, lastSeenAt) => set((state) => {
+    if (lastSeenAt === null) {
+      const { [userId]: _, ...rest } = state.lastSeen;
+      return { lastSeen: rest };
+    }
+    return { lastSeen: { ...state.lastSeen, [userId]: lastSeenAt } };
+  }),
+  setReplyingTo: (message) => set({ replyingTo: message, editingMessage: null }),
+  setEditingMessage: (message) => set({ editingMessage: message, replyingTo: null }),
+  setForwardingMessage: (message) => set({ forwardingMessage: message }),
+  toggleSidebar: () => set((state) => ({ isSidebarOpen: !state.isSidebarOpen })),
+  setSidebarOpen: (open) => set({ isSidebarOpen: open }),
+  toggleGroupInfo: () => set((state) => ({ isGroupInfoOpen: !state.isGroupInfoOpen })),
+  setGroupInfoOpen: (open) => set({ isGroupInfoOpen: open }),
+  toggleStarredPanel: () => set((state) => ({ isStarredPanelOpen: !state.isStarredPanelOpen })),
+  setStarredPanelOpen: (open) => set({ isStarredPanelOpen: open }),
+  setMessageInfoId: (id) => set({ messageInfoId: id })
+}));
+
+export {
+  useChatStore
+};
+//# sourceMappingURL=chunk-QHELYVNT.js.map

package/dist/chunk-QHELYVNT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/stores/chat.store.ts"],"sourcesContent":["import { create } from 'zustand';\nimport type { Message } from '../types/index.js';\n\ninterface TypingUser {\n  userId: string;\n  displayName: string;\n  avatarUrl?: string;\n}\n\nexport interface LastReadEntry {\n  messageId: string;\n  readAt: string;\n}\n\ninterface ChatState {\n  activeConversationId: string | null;\n  pendingTarget: { conversationId: string; messageId: string } | null;\n  typingUsers: Record<string, TypingUser[]>;\n  onlineUsers: string[];\n  /** keyed by conversationId — current user's last read pointer per conversation */\n  lastRead: Record<string, LastReadEntry>;\n  /** keyed by userId — last seen timestamp for each user */\n  lastSeen: Record<string, string>;\n  replyingTo: Message | null;\n  editingMessage: Message | null;\n  /** Message staged in the forward picker, null = picker closed. Unlike replyingTo,\n   * this does not fold into the next composer send — forwarding targets a different\n   * conversation and needs its own conversation-picker UI. */\n  forwardingMessage: Message | null;\n  isSidebarOpen: boolean;\n  isGroupInfoOpen: boolean;\n  isStarredPanelOpen: boolean;\n  /** messageId currently shown in the Message Info panel, null = closed */\n  messageInfoId: string | null;\n\n  setActiveConversation: (id: string | null) => void;\n  setPendingTarget: (target: { conversationId: string; messageId: string } | null) => void;\n  addTypingUser: (conversationId: string, user: TypingUser) => void;\n  removeTypingUser: (conversationId: string, userId: string) => void;\n  /** Drops every typing indicator and cancels their expiry timers. For teardown\n   *  and identity change — a socket drop no longer needs it, since indicators\n   *  expire on their own. */\n  clearTypingUsers: () => void;\n  setUserOnline: (userId: string) => void;\n  setUserOffline: (userId: string) => void;\n  setOnlineUsers: (userIds: string[]) => void;\n  setLastRead: (conversationId: string, messageId: string, readAt: string) => void;\n  setLastSeen: (userId: string, lastSeenAt: string | null) => void;\n  setReplyingTo: (message: Message | null) => void;\n  setEditingMessage: (message: Message | null) => void;\n  setForwardingMessage: (message: Message | null) => void;\n  toggleSidebar: () => void;\n  setSidebarOpen: (open: boolean) => void;\n  toggleGroupInfo: () => void;\n  setGroupInfoOpen: (open: boolean) => void;\n  toggleStarredPanel: () => void;\n  setStarredPanelOpen: (open: boolean) => void;\n  setMessageInfoId: (id: string | null) => void;\n}\n\n/**\n * How long a typing indicator survives without a refreshing event.\n *\n * Must be > chat-core's outbound typing throttle (3s) plus network slack, so a\n * peer who is still typing always re-asserts before their indicator expires.\n * Must also be short enough that a genuinely stale indicator disappears within\n * a couple of seconds of belief becoming wrong.\n */\nconst TYPING_EXPIRY_MS = 6_000;\n\n/** `${conversationId}\\u0000${userId}` → pending expiry timer. */\nconst _typingExpiryTimers = new Map<string, ReturnType<typeof setTimeout>>();\n\nconst typingKey = (conversationId: string, userId: string) => `${conversationId}\\u0000${userId}`;\n\nfunction clearTypingExpiry(conversationId: string, userId: string): void {\n  const key = typingKey(conversationId, userId);\n  const timer = _typingExpiryTimers.get(key);\n  if (timer) {\n    clearTimeout(timer);\n    _typingExpiryTimers.delete(key);\n  }\n}\n\nfunction clearAllTypingExpiry(): void {\n  _typingExpiryTimers.forEach((timer) => clearTimeout(timer));\n  _typingExpiryTimers.clear();\n}\n\n/** (Re)arms the expiry for one typing user. Each refreshing event pushes the\n *  deadline out, so the indicator lives exactly as long as events keep coming. */\nfunction scheduleTypingExpiry(conversationId: string, userId: string): void {\n  const key = typingKey(conversationId, userId);\n  const existing = _typingExpiryTimers.get(key);\n  if (existing) clearTimeout(existing);\n  const timer = setTimeout(() => {\n    _typingExpiryTimers.delete(key);\n    useChatStore.getState().removeTypingUser(conversationId, userId);\n  }, TYPING_EXPIRY_MS);\n  // Never hold a Node process open for an indicator (SSR / tests).\n  (timer as unknown as { unref?: () => void }).unref?.();\n  _typingExpiryTimers.set(key, timer);\n}\n\nexport const useChatStore = create<ChatState>((set) => ({\n  activeConversationId: null,\n  pendingTarget: null,\n  typingUsers: {},\n  onlineUsers: [],\n  lastRead: {},\n  lastSeen: {},\n  replyingTo: null,\n  editingMessage: null,\n  forwardingMessage: null,\n  isSidebarOpen: true,\n  isGroupInfoOpen: false,\n  isStarredPanelOpen: false,\n  messageInfoId: null,\n\n  setActiveConversation: (id) =>\n    set({ activeConversationId: id, replyingTo: null, editingMessage: null, forwardingMessage: null }),\n\n  setPendingTarget: (target) => set({ pendingTarget: target }),\n\n  // Each typing user carries a self-expiring timer, so an indicator can never\n  // outlive the evidence for it. Previously the ONLY things that cleared an\n  // indicator were an explicit isTyping:false from the sender and a local\n  // socket disconnect — so any lost false edge left \"is typing…\" on screen\n  // indefinitely. That is reachable in normal use: a sender whose tab is killed\n  // while their other devices stay connected never triggers the server's\n  // disconnect cleanup (it only fires when the user's LAST socket goes), and\n  // the false edge is fire-and-forget so it is never retried.\n  //\n  // The timer is the authority on liveness; the sender's false edge is now just\n  // a fast path. TYPING_EXPIRY_MS must exceed chat-core's outbound throttle\n  // window (3s) by enough that a still-typing peer always re-asserts before it\n  // fires, otherwise indicators would visibly flicker mid-typing.\n  addTypingUser: (conversationId, user) =>\n    set((state) => {\n      scheduleTypingExpiry(conversationId, user.userId);\n      const existing = state.typingUsers[conversationId] ?? [];\n      const deduped = existing.filter((u) => u.userId !== user.userId);\n      return { typingUsers: { ...state.typingUsers, [conversationId]: [...deduped, user] } };\n    }),\n\n  removeTypingUser: (conversationId, userId) =>\n    set((state) => {\n      clearTypingExpiry(conversationId, userId);\n      const existing = state.typingUsers[conversationId];\n      // Nothing to remove — return the SAME state object so subscribers don't\n      // re-render. Without this guard the expiry timer and a real false edge\n      // racing on the same user would publish a new (identical) map twice.\n      if (!existing || !existing.some((u) => u.userId === userId)) return state;\n      return {\n        typingUsers: {\n          ...state.typingUsers,\n          [conversationId]: existing.filter((u) => u.userId !== userId),\n        },\n      };\n    }),\n\n  clearTypingUsers: () => {\n    clearAllTypingExpiry();\n    set({ typingUsers: {} });\n  },\n\n  setUserOnline: (userId) =>\n    set((state) => ({\n      onlineUsers: state.onlineUsers.includes(userId)\n        ? state.onlineUsers\n        : [...state.onlineUsers, userId],\n    })),\n\n  setUserOffline: (userId) =>\n    set((state) => ({ onlineUsers: state.onlineUsers.filter((id) => id !== userId) })),\n\n  setOnlineUsers: (userIds) => set({ onlineUsers: userIds }),\n\n  setLastRead: (conversationId, messageId, readAt) =>\n    set((state) => ({\n      lastRead: { ...state.lastRead, [conversationId]: { messageId, readAt } },\n    })),\n\n  setLastSeen: (userId, lastSeenAt) =>\n    set((state) => {\n      if (lastSeenAt === null) {\n        const { [userId]: _, ...rest } = state.lastSeen;\n        return { lastSeen: rest };\n      }\n      return { lastSeen: { ...state.lastSeen, [userId]: lastSeenAt } };\n    }),\n\n  setReplyingTo: (message) => set({ replyingTo: message, editingMessage: null }),\n\n  setEditingMessage: (message) => set({ editingMessage: message, replyingTo: null }),\n\n  setForwardingMessage: (message) => set({ forwardingMessage: message }),\n\n  toggleSidebar: () => set((state) => ({ isSidebarOpen: !state.isSidebarOpen })),\n  setSidebarOpen: (open) => set({ isSidebarOpen: open }),\n\n  toggleGroupInfo: () => set((state) => ({ isGroupInfoOpen: !state.isGroupInfoOpen })),\n  setGroupInfoOpen: (open) => set({ isGroupInfoOpen: open }),\n\n  toggleStarredPanel: () => set((state) => ({ isStarredPanelOpen: !state.isStarredPanelOpen })),\n  setStarredPanelOpen: (open) => set({ isStarredPanelOpen: open }),\n\n  setMessageInfoId: (id: string | null) => set({ messageInfoId: id }),\n}));\n"],"mappings":"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","names":[]}

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]
       })),
@@ -147,9 +194,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,
@@ -1237,6 +1286,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 +1494,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 +1549,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 +1685,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 } : {} });
@@ -2368,9 +2472,11 @@ var AntzChatClient = class {
   readRetryAfterMs,
   reconnectSocket,
   refreshSocketAuth,
+  registerTeardownHook,
   renderMentionParts,
   resetAuthStore,
   resetTrackedRooms,
+  resetTypingThrottle,
   resolveConfig,
   resolveSystemMessageText,
   setApiClientInstance,