@antzsoft/chat-core 1.4.5 → 1.4.7

package/README.md

@@ -380,9 +380,48 @@ interface AntzChatConfig {
    * Optional — sensible defaults are applied for all sub-fields.
    */
   upload?: UploadConfig;
+
+  /**
+   * Called when sending a message ultimately fails, after the SDK has already
+   * updated the timeline (removed the bubble for permanent failures, flagged it
+   * retryable otherwise). Use it to surface a toast or error banner. v1.4.5+.
+   * Optional.
+   */
+  onSendError?: (error: Error, context: SendErrorContext) => void;
+}
+```
+
+### `SendErrorContext` (v1.4.5+)
+
+Passed as the second argument to `onSendError`. The callback fires *after* the SDK has reconciled the timeline, so it is for user-facing notification only — you do not need to remove or flag the bubble yourself.
+
+```typescript
+interface SendErrorContext {
+  conversationId: string;
+  /** tempId of the optimistic message the failure belongs to. */
+  tempId: string;
+  /**
+   * True when resending the identical payload cannot succeed (file size/type
+   * limits, message too long, no longer a participant, ...). The SDK has removed
+   * the optimistic message from the timeline. False for transient failures
+   * (network / socket / generic server error), where a "! Retry" bubble stays.
+   */
+  permanent: boolean;
 }
 ```
 
+```typescript
+const client = new AntzChatClient({
+  apiUrl, persistStorage, platformUploadFn,
+  onSendError: (error, { permanent }) => {
+    if (permanent) toast.error(error.message);
+    else toast.warn('Message not sent — tap Retry on the message.');
+  },
+});
+```
+
+Pair `permanent: false` with `useChat().retrySendMessage(messageId)` (v1.4.4+) if you want a retry affordance outside the built-in `MessageItem`.
+
 ### `PersistStorage`
 
 Supports both synchronous (localStorage) and asynchronous (AsyncStorage) storage backends.
@@ -2420,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
@@ -2436,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);
@@ -2608,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. |
@@ -3244,6 +3285,40 @@ document.querySelectorAll('[data-conv-id]').forEach((el) => {
 
 ## Changelog
 
+> **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).
+
+- **Fix: transit encryption no longer degrades to plaintext or wedges after a socket drop.** Six related fixes, all of them closing a path where the SDK either sent an unencrypted request the server was certain to reject with `403 "Transit encryption required"`, or blocked forever on a handshake nothing was driving:
+  - The socket `disconnect` handler cleared the REST transit session on *every* websocket blip (network hiccup, backgrounded tab, server redeploy), after which every chat REST call 403'd until a full page reload. The REST session is independent of the socket transport and is now torn down only on an explicit `disconnectSocket()` or auth change.
+  - `clearTransitSession()` left `sessionEverEstablished = true`, making `waitForTransitReady()` ("don't block") and `isTransitEnabled()` ("don't encrypt") permanently disagree — requests went out unencrypted and 403'd with no recovery path. The flag now resets with the session.
+  - The 5s `transit_session` safety timeout called `configureTransit(false)`, turning a transient stall into plaintext for the rest of the session. A timeout now leaves transit required; only `GET /crypto/pubkey` returning `enabled: false` can authoritatively disable it.
+  - The interceptor gated its transit wait on the presence of an auth token, so pre-auth calls (`GET /app/config` before an async `authProvider` resolves) raced ahead and 403'd. It now gates on whether transit is configured.
+  - A `join_room` dropped during the handshake gap left the client outside the server-side room with no error and no retry, silently killing `new_message` delivery for that conversation. Joined rooms are now tracked and re-emitted whenever a transit session (re-)establishes or the socket reconnects.
+  - The per-conversation send queue awaited the full server ack before starting the next message. It now awaits only the emit phase, preserving on-the-wire ordering without paying round-trip latency.
+
+- **Changed: requests fail loudly instead of hanging or downgrading.** With transit required and no session key, a REST request waits up to 30s for an in-flight handshake, then throws a **retryable** `AntzChatNetworkError` with code `TRANSIT_NOT_READY`; socket emits do the same on a 4s budget. Neither ever falls through to plaintext. The REST handshake retries itself up to 5 times with exponential backoff.
+
+- **New: `onSendError`.** A config callback — `(error, { conversationId, tempId, permanent })` — fired when a send ultimately fails, after the SDK has updated the timeline, so you can raise a toast. `permanent: true` means a retry of the identical payload cannot succeed and the optimistic bubble was removed; `false` leaves a retryable "! Retry" bubble. New type: `SendErrorContext`.
+
+- **New exports:** `setAuthReadyPromise()` (gate the interceptor until your auth token resolves), `resetTrackedRooms()` (call on a user/tenant switch so the reconnect re-flush cannot re-join the previous user's rooms — a token refresh is *not* an identity change), and `isApiClientConfigured()`.
+
+  **Backward compatible at the API level** — additive exports only, no signature changes, no call-site updates required. **One behavioral change needs your attention:** a call that previously went out as plaintext and returned `403` now throws a retryable error instead. Audit any REST call you fire and forget during startup — `getMe().then(...).catch(() => {})` will swallow `TRANSIT_NOT_READY`, leaving auth unresolved, the socket unconnected, and the app stuck on a loading screen with no visible cause. See [CHANGELOG.md](CHANGELOG.md) → *Upgrading from 1.4.4* for the retry patterns.
+
 ### v1.4.1
 
 - **New: manual "mark as unread."** A conversation can now be flagged unread independently of `unreadCount` — the same UX as WhatsApp/Telegram's "mark as unread": re-flag a conversation you've already read so it stands out again, without fabricating unread messages.
@@ -3258,7 +3333,9 @@ document.querySelectorAll('[data-conv-id]').forEach((el) => {
 
 - **Fix: stale transit encryption key after token refresh, causing continuous `"Transit decryption failed for event: user_online"` spam.** `reconnectSocket()` called `socket.connect()` to apply a refreshed token while preserving the transit session — but socket.io-client's `connect()` is a no-op on an already-connected socket. A token refresh fires while the user is actively on a chat screen (socket still connected), so the new auth was never actually sent; the socket kept running on the stale token until the server eventually dropped it, and the disconnect handler then cleared the transit session, desyncing the client's key from the server's.
 
-  **Fix:** in the transit branch of `reconnectSocket()`, force a real transport re-cycle (disconnect → connect) so the fresh auth (token + `transitSessionId`) is actually sent and the server re-links the *same* session (same key), instead of silently continuing on stale auth. A new internal `_preservingSession` guard stops the disconnect handler from wiping the key being deliberately carried forward. Non-transit and already-disconnected paths are unchanged.
+  **Fix:** in the transit branch of `reconnectSocket()`, force a real transport re-cycle (disconnect → connect) so the fresh auth (token + `transitSessionId`) is actually sent and the server re-links the *same* session (same key), instead of silently continuing on stale auth. Non-transit and already-disconnected paths are unchanged.
+
+  > **Superseded in v1.4.5.** This fix originally added an internal `_preservingSession` guard to stop the disconnect handler from wiping the key being carried through the re-cycle. v1.4.5 removed that guard: the disconnect handler no longer clears the transit session on a transient drop at all, so there is nothing to guard against. The transport re-cycle described above is unchanged.
 
   **Backward compatible.** Only affects transit-encryption deployments that refresh auth tokens while the socket is connected. **No integration changes required** — the fix is entirely internal to `reconnectSocket()`.
 

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":";AAAA,SAAS,cAAc;AAoEvB,IAAM,mBAAmB;AAGzB,IAAM,sBAAsB,oBAAI,IAA2C;AAE3E,IAAM,YAAY,CAAC,gBAAwB,WAAmB,GAAG,cAAc,KAAS,MAAM;AAE9F,SAAS,kBAAkB,gBAAwB,QAAsB;AACvE,QAAM,MAAM,UAAU,gBAAgB,MAAM;AAC5C,QAAM,QAAQ,oBAAoB,IAAI,GAAG;AACzC,MAAI,OAAO;AACT,iBAAa,KAAK;AAClB,wBAAoB,OAAO,GAAG;AAAA,EAChC;AACF;AAEA,SAAS,uBAA6B;AACpC,sBAAoB,QAAQ,CAAC,UAAU,aAAa,KAAK,CAAC;AAC1D,sBAAoB,MAAM;AAC5B;AAIA,SAAS,qBAAqB,gBAAwB,QAAsB;AAC1E,QAAM,MAAM,UAAU,gBAAgB,MAAM;AAC5C,QAAM,WAAW,oBAAoB,IAAI,GAAG;AAC5C,MAAI,SAAU,cAAa,QAAQ;AACnC,QAAM,QAAQ,WAAW,MAAM;AAC7B,wBAAoB,OAAO,GAAG;AAC9B,iBAAa,SAAS,EAAE,iBAAiB,gBAAgB,MAAM;AAAA,EACjE,GAAG,gBAAgB;AAEnB,EAAC,MAA4C,QAAQ;AACrD,sBAAoB,IAAI,KAAK,KAAK;AACpC;AAEO,IAAM,eAAe,OAAkB,CAAC,SAAS;AAAA,EACtD,sBAAsB;AAAA,EACtB,eAAe;AAAA,EACf,aAAa,CAAC;AAAA,EACd,aAAa,CAAC;AAAA,EACd,UAAU,CAAC;AAAA,EACX,UAAU,CAAC;AAAA,EACX,YAAY;AAAA,EACZ,gBAAgB;AAAA,EAChB,mBAAmB;AAAA,EACnB,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,oBAAoB;AAAA,EACpB,eAAe;AAAA,EAEf,uBAAuB,CAAC,OACtB,IAAI,EAAE,sBAAsB,IAAI,YAAY,MAAM,gBAAgB,MAAM,mBAAmB,KAAK,CAAC;AAAA,EAEnG,kBAAkB,CAAC,WAAW,IAAI,EAAE,eAAe,OAAO,CAAC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAe3D,eAAe,CAAC,gBAAgB,SAC9B,IAAI,CAAC,UAAU;AACb,yBAAqB,gBAAgB,KAAK,MAAM;AAChD,UAAM,WAAW,MAAM,YAAY,cAAc,KAAK,CAAC;AACvD,UAAM,UAAU,SAAS,OAAO,CAAC,MAAM,EAAE,WAAW,KAAK,MAAM;AAC/D,WAAO,EAAE,aAAa,EAAE,GAAG,MAAM,aAAa,CAAC,cAAc,GAAG,CAAC,GAAG,SAAS,IAAI,EAAE,EAAE;AAAA,EACvF,CAAC;AAAA,EAEH,kBAAkB,CAAC,gBAAgB,WACjC,IAAI,CAAC,UAAU;AACb,sBAAkB,gBAAgB,MAAM;AACxC,UAAM,WAAW,MAAM,YAAY,cAAc;AAIjD,QAAI,CAAC,YAAY,CAAC,SAAS,KAAK,CAAC,MAAM,EAAE,WAAW,MAAM,EAAG,QAAO;AACpE,WAAO;AAAA,MACL,aAAa;AAAA,QACX,GAAG,MAAM;AAAA,QACT,CAAC,cAAc,GAAG,SAAS,OAAO,CAAC,MAAM,EAAE,WAAW,MAAM;AAAA,MAC9D;AAAA,IACF;AAAA,EACF,CAAC;AAAA,EAEH,kBAAkB,MAAM;AACtB,yBAAqB;AACrB,QAAI,EAAE,aAAa,CAAC,EAAE,CAAC;AAAA,EACzB;AAAA,EAEA,eAAe,CAAC,WACd,IAAI,CAAC,WAAW;AAAA,IACd,aAAa,MAAM,YAAY,SAAS,MAAM,IAC1C,MAAM,cACN,CAAC,GAAG,MAAM,aAAa,MAAM;AAAA,EACnC,EAAE;AAAA,EAEJ,gBAAgB,CAAC,WACf,IAAI,CAAC,WAAW,EAAE,aAAa,MAAM,YAAY,OAAO,CAAC,OAAO,OAAO,MAAM,EAAE,EAAE;AAAA,EAEnF,gBAAgB,CAAC,YAAY,IAAI,EAAE,aAAa,QAAQ,CAAC;AAAA,EAEzD,aAAa,CAAC,gBAAgB,WAAW,WACvC,IAAI,CAAC,WAAW;AAAA,IACd,UAAU,EAAE,GAAG,MAAM,UAAU,CAAC,cAAc,GAAG,EAAE,WAAW,OAAO,EAAE;AAAA,EACzE,EAAE;AAAA,EAEJ,aAAa,CAAC,QAAQ,eACpB,IAAI,CAAC,UAAU;AACb,QAAI,eAAe,MAAM;AACvB,YAAM,EAAE,CAAC,MAAM,GAAG,GAAG,GAAG,KAAK,IAAI,MAAM;AACvC,aAAO,EAAE,UAAU,KAAK;AAAA,IAC1B;AACA,WAAO,EAAE,UAAU,EAAE,GAAG,MAAM,UAAU,CAAC,MAAM,GAAG,WAAW,EAAE;AAAA,EACjE,CAAC;AAAA,EAEH,eAAe,CAAC,YAAY,IAAI,EAAE,YAAY,SAAS,gBAAgB,KAAK,CAAC;AAAA,EAE7E,mBAAmB,CAAC,YAAY,IAAI,EAAE,gBAAgB,SAAS,YAAY,KAAK,CAAC;AAAA,EAEjF,sBAAsB,CAAC,YAAY,IAAI,EAAE,mBAAmB,QAAQ,CAAC;AAAA,EAErE,eAAe,MAAM,IAAI,CAAC,WAAW,EAAE,eAAe,CAAC,MAAM,cAAc,EAAE;AAAA,EAC7E,gBAAgB,CAAC,SAAS,IAAI,EAAE,eAAe,KAAK,CAAC;AAAA,EAErD,iBAAiB,MAAM,IAAI,CAAC,WAAW,EAAE,iBAAiB,CAAC,MAAM,gBAAgB,EAAE;AAAA,EACnF,kBAAkB,CAAC,SAAS,IAAI,EAAE,iBAAiB,KAAK,CAAC;AAAA,EAEzD,oBAAoB,MAAM,IAAI,CAAC,WAAW,EAAE,oBAAoB,CAAC,MAAM,mBAAmB,EAAE;AAAA,EAC5F,qBAAqB,CAAC,SAAS,IAAI,EAAE,oBAAoB,KAAK,CAAC;AAAA,EAE/D,kBAAkB,CAAC,OAAsB,IAAI,EAAE,eAAe,GAAG,CAAC;AACpE,EAAE;","names":[]}

package/dist/{chunk-WUNH3UTE.js → chunk-U637W5MD.js}

@@ -263,11 +263,36 @@ function resetAlgoCache() {
 }
 
 // src/crypto/handshake.ts
+function readRetryAfterMs(headers) {
+  const parse = (raw) => {
+    if (!raw) return void 0;
+    const secs = Number(raw);
+    if (Number.isFinite(secs)) return Math.max(0, secs * 1e3);
+    const when = Date.parse(raw);
+    return Number.isNaN(when) ? void 0 : Math.max(0, when - Date.now());
+  };
+  const found = ["Retry-After-identity", "Retry-After-ip", "Retry-After"].map((name) => parse(headers.get(name))).filter((ms) => ms != null);
+  return found.length > 0 ? Math.max(...found) : void 0;
+}
+var TransitRateLimitedError = class extends Error {
+  constructor(retryAfterMs) {
+    super("[AntzChat] transit handshake rate-limited (429)");
+    this.name = "TransitRateLimitedError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+function identityHeaders(identity) {
+  const headers = {};
+  if (identity?.userId) headers["x-user-id"] = identity.userId;
+  if (identity?.tenantId) headers["X-Tenant-ID"] = identity.tenantId;
+  return headers;
+}
 function hasWebCrypto2() {
   return typeof globalThis.crypto?.subtle !== "undefined";
 }
-async function fetchServerKeys(apiUrl) {
-  const res = await fetch(`${apiUrl}/crypto/pubkey`);
+async function fetchServerKeys(apiUrl, identity) {
+  const res = await fetch(`${apiUrl}/crypto/pubkey`, { headers: identityHeaders(identity) });
+  if (res.status === 429) throw new TransitRateLimitedError(readRetryAfterMs(res.headers));
   if (!res.ok) throw new Error(`[AntzChat] Failed to fetch server public key: ${res.status}`);
   const body = await res.json();
   return body?.data ?? body;
@@ -278,24 +303,26 @@ async function generateEphemeralKey(algo, serverKeys) {
   }
   return generateNobleEphemeralKey(serverKeys);
 }
-async function createRestTransitSession(apiUrl) {
+async function createRestTransitSession(apiUrl, identity) {
   try {
-    const serverKeys = await fetchServerKeys(apiUrl);
+    const serverKeys = await fetchServerKeys(apiUrl, identity);
     if (!serverKeys.enabled) return null;
     const algo = hasWebCrypto2() ? await detectTransitAlgo() : "x25519";
     const { ephemeralPubB64, deriveSessionKey } = await generateEphemeralKey(algo, serverKeys);
     const res = await fetch(`${apiUrl}/crypto/session`, {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
+      headers: { "Content-Type": "application/json", ...identityHeaders(identity) },
       body: JSON.stringify({ ephemeralPub: ephemeralPubB64, algo })
     });
+    if (res.status === 429) throw new TransitRateLimitedError(readRetryAfterMs(res.headers));
     if (!res.ok) return null;
     const body = await res.json();
     const sessionId = (body?.data ?? body)?.sessionId ?? body?.sessionId;
     if (!sessionId) return null;
     const sessionKey = await deriveSessionKey(sessionId);
     return { sessionId, sessionKey };
-  } catch {
+  } catch (err) {
+    if (err instanceof TransitRateLimitedError) throw err;
     return null;
   }
 }
@@ -494,26 +521,46 @@ function ensureRestTransitHandshake() {
   const apiUrl = _config.apiUrl;
   _transitHandshakePromise = (async () => {
     try {
-      for (let attempt = 0; attempt < 5; attempt++) {
+      const MAX_FAILURES = 5;
+      const BACKSTOP_MS = 2 * 6e4;
+      const deadline = Date.now() + BACKSTOP_MS;
+      let failures = 0;
+      let rateLimitHits = 0;
+      while (failures < MAX_FAILURES && Date.now() < deadline) {
         if (getTransitSession()) return;
+        let waitMs;
         try {
-          const keys = await fetchServerKeys(apiUrl);
+          const identity = { userId: _config?.userId, tenantId: _config?.tenantId };
+          const keys = await fetchServerKeys(apiUrl, identity);
           if (!keys?.enabled) {
             configureTransit(false);
             return;
           }
-          const session = await createRestTransitSession(apiUrl);
+          const session = await createRestTransitSession(apiUrl, identity);
           if (session && !getTransitSession()) {
             const algo = typeof globalThis.crypto?.subtle !== "undefined" ? await detectTransitAlgo() : "x25519";
             setTransitSession({ sessionKey: session.sessionKey, algo, sessionId: session.sessionId, enabled: true });
             return;
           }
-        } catch {
+          failures++;
+          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;
+            rateLimitHits++;
+            console.warn(
+              `[AntzChat] transit handshake rate-limited (429) \u2014 retrying in ${Math.round(waitMs / 1e3)}s${err.retryAfterMs != null ? " (per Retry-After)" : ""}.`
+            );
+          } else {
+            failures++;
+            waitMs = Math.min(500 * 2 ** failures, 8e3);
+          }
         }
-        await new Promise((r) => setTimeout(r, Math.min(500 * 2 ** attempt, 8e3)));
+        await new Promise((r) => setTimeout(r, waitMs));
       }
       console.error(
-        "[AntzChat] transit handshake could not establish a session after 5 attempts \u2014 chat requests stay gated until one succeeds (server requires transit)."
+        "[AntzChat] transit handshake could not establish a session \u2014 chat requests stay gated until one succeeds (server requires transit)."
       );
     } finally {
       _transitHandshakePromise = null;
@@ -842,6 +889,8 @@ export {
   getSessionId,
   detectTransitAlgo,
   resetAlgoCache,
+  readRetryAfterMs,
+  TransitRateLimitedError,
   fetchServerKeys,
   generateEphemeralKey,
   createRestTransitSession,
@@ -865,4 +914,4 @@ export {
   uploadBatch,
   uploadBatchWithSlots
 };
-//# sourceMappingURL=chunk-WUNH3UTE.js.map
+//# sourceMappingURL=chunk-U637W5MD.js.map