@pedi/chika-sdk 1.0.2 → 1.0.5

package/README.md

@@ -19,6 +19,7 @@ Provides a drop-in React hook (`useChat`) that connects your React Native app to
 
 - `useChat<D>()` React hook with full TypeScript generics
 - `createChatSession<D>()` imperative API for non-React usage
+- **`useUnread()` hook** — Real-time unread count tracking via dedicated SSE stream with passive listening support
 - Automatic SSE reconnection with configurable delay
 - Platform-aware AppState handling (iOS vs Android)
 - Optimistic message sending with deduplication
@@ -45,6 +46,31 @@ function ChatScreen({ bookingId, user }) {
 }
 ```
 
+### Unread Notifications
+
+Monitor unread message counts in real-time — even for channels the user hasn't joined yet:
+
+```typescript
+import { useUnread } from '@pedi/chika-sdk';
+
+function ChatListItem({ channelId, userId, config }) {
+  const { unreadCount, hasUnread, lastMessageAt } = useUnread({
+    config,
+    channelId,
+    participantId: userId,
+  });
+
+  return (
+    <View>
+      <Text>{channelId}</Text>
+      {hasUnread && <Badge count={unreadCount} />}
+    </View>
+  );
+}
+```
+
+The hook handles SSE reconnection and AppState-aware lifecycle management automatically. Disable it with `enabled: false` when `useChat` is already active on the same channel.
+
 **Peer dependencies:** `react >= 18`, `react-native >= 0.72`
 
 ## Documentation

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { ChatManifest, ChatDomain, DefaultDomain, Participant, Message, MessageAttributes, SendMessageResponse } from '@pedi/chika-types';
-export { ChatBucket, ChatDomain, ChatManifest, DefaultDomain, Message, MessageAttributes, Participant, PediChat, PediLocation, PediMessageAttributes, PediMessageType, PediParticipantMeta, PediRole, PediVehicle, SendMessageResponse } from '@pedi/chika-types';
+export { ChatBucket, ChatDomain, ChatManifest, DefaultDomain, MarkReadRequest, Message, MessageAttributes, Participant, PediChat, PediLocation, PediMessageAttributes, PediMessageType, PediParticipantMeta, PediRole, PediVehicle, SSEUnreadClearEvent, SSEUnreadEvent, SSEUnreadUpdateEvent, SendMessageResponse, UnreadCountResponse } from '@pedi/chika-types';
 
 type ChatStatus = 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'closed' | 'error';
 /**
@@ -49,6 +49,20 @@ interface UseChatReturn<D extends ChatDomain = DefaultDomain> {
  */
 declare function useChat<D extends ChatDomain = DefaultDomain>({ config, channelId, profile, onMessage }: UseChatOptions<D>): UseChatReturn<D>;
 
+interface UseUnreadOptions {
+    config: ChatConfig;
+    channelId: string;
+    participantId: string;
+    enabled?: boolean;
+}
+interface UseUnreadReturn {
+    unreadCount: number;
+    hasUnread: boolean;
+    lastMessageAt: string | null;
+    error: Error | null;
+}
+declare function useUnread(options: UseUnreadOptions): UseUnreadReturn;
+
 interface SessionCallbacks<D extends ChatDomain = DefaultDomain> {
     onMessage: (message: Message<D>) => void;
     onStatusChange: (status: ChatStatus) => void;
@@ -61,14 +75,9 @@ interface ChatSession<D extends ChatDomain = DefaultDomain> {
     initialParticipants: Participant<D>[];
     initialMessages: Message<D>[];
     sendMessage: (type: D['messageType'], body: string, attributes?: MessageAttributes<D>) => Promise<SendMessageResponse>;
+    markAsRead: (messageId: string) => Promise<void>;
     disconnect: () => void;
 }
-/**
- * Creates an imperative chat session with SSE streaming and managed reconnection.
- * Lower-level API — prefer `useChat` hook for React Native components.
- *
- * @template D - Chat domain type. Defaults to DefaultDomain.
- */
 declare function createChatSession<D extends ChatDomain = DefaultDomain>(config: ChatConfig, channelId: string, profile: Participant<D>, callbacks: SessionCallbacks<D>): Promise<ChatSession<D>>;
 
 /**
@@ -82,6 +91,25 @@ declare function createChatSession<D extends ChatDomain = DefaultDomain>(config:
 declare function createManifest(serverUrl: string): ChatManifest;
 declare function resolveServerUrl(manifest: ChatManifest, channelId: string): string;
 
+interface SSEConnectionConfig {
+    url: string;
+    headers?: Record<string, string>;
+    reconnectDelayMs?: number;
+    lastEventId?: string;
+    customEvents?: string[];
+}
+interface SSEConnectionCallbacks {
+    onOpen?: () => void;
+    onEvent: (eventType: string, data: string, lastEventId?: string) => void;
+    onError?: (error: Error) => void;
+    onClosed?: () => void;
+    onReconnecting?: () => void;
+}
+interface SSEConnection {
+    close: () => void;
+}
+declare function createSSEConnection(config: SSEConnectionConfig, callbacks: SSEConnectionCallbacks): SSEConnection;
+
 declare class ChatDisconnectedError extends Error {
     readonly status: ChatStatus;
     constructor(status: ChatStatus);
@@ -91,4 +119,4 @@ declare class ChannelClosedError extends Error {
     constructor(channelId: string);
 }
 
-export { ChannelClosedError, type ChatConfig, ChatDisconnectedError, type ChatSession, type ChatStatus, type SessionCallbacks, type UseChatOptions, type UseChatReturn, createChatSession, createManifest, resolveServerUrl, useChat };
+export { ChannelClosedError, type ChatConfig, ChatDisconnectedError, type ChatSession, type ChatStatus, type SSEConnection, type SSEConnectionCallbacks, type SSEConnectionConfig, type SessionCallbacks, type UseChatOptions, type UseChatReturn, type UseUnreadOptions, type UseUnreadReturn, createChatSession, createManifest, createSSEConnection, resolveServerUrl, useChat, useUnread };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { ChatManifest, ChatDomain, DefaultDomain, Participant, Message, MessageAttributes, SendMessageResponse } from '@pedi/chika-types';
-export { ChatBucket, ChatDomain, ChatManifest, DefaultDomain, Message, MessageAttributes, Participant, PediChat, PediLocation, PediMessageAttributes, PediMessageType, PediParticipantMeta, PediRole, PediVehicle, SendMessageResponse } from '@pedi/chika-types';
+export { ChatBucket, ChatDomain, ChatManifest, DefaultDomain, MarkReadRequest, Message, MessageAttributes, Participant, PediChat, PediLocation, PediMessageAttributes, PediMessageType, PediParticipantMeta, PediRole, PediVehicle, SSEUnreadClearEvent, SSEUnreadEvent, SSEUnreadUpdateEvent, SendMessageResponse, UnreadCountResponse } from '@pedi/chika-types';
 
 type ChatStatus = 'connecting' | 'connected' | 'reconnecting' | 'disconnected' | 'closed' | 'error';
 /**
@@ -49,6 +49,20 @@ interface UseChatReturn<D extends ChatDomain = DefaultDomain> {
  */
 declare function useChat<D extends ChatDomain = DefaultDomain>({ config, channelId, profile, onMessage }: UseChatOptions<D>): UseChatReturn<D>;
 
+interface UseUnreadOptions {
+    config: ChatConfig;
+    channelId: string;
+    participantId: string;
+    enabled?: boolean;
+}
+interface UseUnreadReturn {
+    unreadCount: number;
+    hasUnread: boolean;
+    lastMessageAt: string | null;
+    error: Error | null;
+}
+declare function useUnread(options: UseUnreadOptions): UseUnreadReturn;
+
 interface SessionCallbacks<D extends ChatDomain = DefaultDomain> {
     onMessage: (message: Message<D>) => void;
     onStatusChange: (status: ChatStatus) => void;
@@ -61,14 +75,9 @@ interface ChatSession<D extends ChatDomain = DefaultDomain> {
     initialParticipants: Participant<D>[];
     initialMessages: Message<D>[];
     sendMessage: (type: D['messageType'], body: string, attributes?: MessageAttributes<D>) => Promise<SendMessageResponse>;
+    markAsRead: (messageId: string) => Promise<void>;
     disconnect: () => void;
 }
-/**
- * Creates an imperative chat session with SSE streaming and managed reconnection.
- * Lower-level API — prefer `useChat` hook for React Native components.
- *
- * @template D - Chat domain type. Defaults to DefaultDomain.
- */
 declare function createChatSession<D extends ChatDomain = DefaultDomain>(config: ChatConfig, channelId: string, profile: Participant<D>, callbacks: SessionCallbacks<D>): Promise<ChatSession<D>>;
 
 /**
@@ -82,6 +91,25 @@ declare function createChatSession<D extends ChatDomain = DefaultDomain>(config:
 declare function createManifest(serverUrl: string): ChatManifest;
 declare function resolveServerUrl(manifest: ChatManifest, channelId: string): string;
 
+interface SSEConnectionConfig {
+    url: string;
+    headers?: Record<string, string>;
+    reconnectDelayMs?: number;
+    lastEventId?: string;
+    customEvents?: string[];
+}
+interface SSEConnectionCallbacks {
+    onOpen?: () => void;
+    onEvent: (eventType: string, data: string, lastEventId?: string) => void;
+    onError?: (error: Error) => void;
+    onClosed?: () => void;
+    onReconnecting?: () => void;
+}
+interface SSEConnection {
+    close: () => void;
+}
+declare function createSSEConnection(config: SSEConnectionConfig, callbacks: SSEConnectionCallbacks): SSEConnection;
+
 declare class ChatDisconnectedError extends Error {
     readonly status: ChatStatus;
     constructor(status: ChatStatus);
@@ -91,4 +119,4 @@ declare class ChannelClosedError extends Error {
     constructor(channelId: string);
 }
 
-export { ChannelClosedError, type ChatConfig, ChatDisconnectedError, type ChatSession, type ChatStatus, type SessionCallbacks, type UseChatOptions, type UseChatReturn, createChatSession, createManifest, resolveServerUrl, useChat };
+export { ChannelClosedError, type ChatConfig, ChatDisconnectedError, type ChatSession, type ChatStatus, type SSEConnection, type SSEConnectionCallbacks, type SSEConnectionConfig, type SessionCallbacks, type UseChatOptions, type UseChatReturn, type UseUnreadOptions, type UseUnreadReturn, createChatSession, createManifest, createSSEConnection, resolveServerUrl, useChat, useUnread };

package/dist/index.js

@@ -34,8 +34,10 @@ __export(index_exports, {
   ChatDisconnectedError: () => ChatDisconnectedError,
   createChatSession: () => createChatSession,
   createManifest: () => createManifest,
+  createSSEConnection: () => createSSEConnection,
   resolveServerUrl: () => resolveServerUrl,
-  useChat: () => useChat
+  useChat: () => useChat,
+  useUnread: () => useUnread
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -59,9 +61,6 @@ var ChannelClosedError = class extends Error {
   }
 };
 
-// src/session.ts
-var import_react_native_sse = __toESM(require("react-native-sse"));
-
 // src/resolve-url.ts
 function createManifest(serverUrl) {
   return { buckets: [{ group: "default", range: [0, 99], server_url: serverUrl }] };
@@ -75,86 +74,68 @@ function resolveServerUrl(manifest, channelId) {
   return bucket.server_url;
 }
 
-// src/session.ts
+// src/sse-connection.ts
+var import_react_native_sse = __toESM(require("react-native-sse"));
 var DEFAULT_RECONNECT_DELAY_MS = 3e3;
-var MAX_SEEN_IDS = 500;
-async function createChatSession(config, channelId, profile, callbacks) {
-  const serviceUrl = resolveServerUrl(config.manifest, channelId);
-  const customHeaders = config.headers ?? {};
+function createSSEConnection(config, callbacks) {
   const reconnectDelay = config.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
-  callbacks.onStatusChange("connecting");
-  const joinRes = await fetch(`${serviceUrl}/channels/${channelId}/join`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...customHeaders },
-    body: JSON.stringify(profile)
-  });
-  if (joinRes.status === 410) {
-    throw new ChannelClosedError(channelId);
-  }
-  if (!joinRes.ok) {
-    throw new Error(`Join failed: ${joinRes.status} ${await joinRes.text()}`);
-  }
-  const { messages, participants, joined_at } = await joinRes.json();
-  let lastEventId = messages.length > 0 ? messages[messages.length - 1].id : void 0;
-  const joinedAt = joined_at;
-  const seenMessageIds = new Set(messages.map((m) => m.id));
+  const customEvents = config.customEvents ?? [];
+  let currentLastEventId = config.lastEventId;
   let es = null;
   let disposed = false;
   let reconnectTimer = null;
-  function trimSeenIds() {
-    if (seenMessageIds.size <= MAX_SEEN_IDS) return;
-    const ids = [...seenMessageIds];
-    seenMessageIds.clear();
-    for (const id of ids.slice(-MAX_SEEN_IDS)) {
-      seenMessageIds.add(id);
+  function cleanup() {
+    if (es) {
+      es.removeAllEventListeners();
+      es.close();
+      es = null;
     }
   }
+  function scheduleReconnect() {
+    if (disposed || reconnectTimer) return;
+    callbacks.onReconnecting?.();
+    cleanup();
+    reconnectTimer = setTimeout(() => {
+      reconnectTimer = null;
+      connect();
+    }, reconnectDelay);
+  }
   function connect() {
     if (disposed) return;
-    const streamUrl = lastEventId ? `${serviceUrl}/channels/${channelId}/stream` : `${serviceUrl}/channels/${channelId}/stream?since_time=${encodeURIComponent(joinedAt)}`;
-    es = new import_react_native_sse.default(streamUrl, {
+    es = new import_react_native_sse.default(config.url, {
       headers: {
-        ...customHeaders,
-        ...lastEventId && { "Last-Event-ID": lastEventId }
+        ...config.headers,
+        ...currentLastEventId && { "Last-Event-ID": currentLastEventId }
       },
       pollingInterval: 0
     });
     es.addEventListener("open", () => {
       if (disposed) return;
-      callbacks.onStatusChange("connected");
+      callbacks.onOpen?.();
     });
     es.addEventListener("message", (event) => {
       if (disposed || !event.data) return;
-      let message;
-      try {
-        message = JSON.parse(event.data);
-      } catch {
-        callbacks.onError(new Error("Failed to parse SSE message"));
-        return;
-      }
       if (event.lastEventId) {
-        lastEventId = event.lastEventId;
+        currentLastEventId = event.lastEventId;
       }
-      if (seenMessageIds.has(message.id)) return;
-      seenMessageIds.add(message.id);
-      trimSeenIds();
-      callbacks.onMessage(message);
-    });
-    es.addEventListener("resync", () => {
-      if (disposed) return;
-      cleanupEventSource();
-      callbacks.onResync();
+      callbacks.onEvent("message", event.data, event.lastEventId ?? void 0);
     });
+    for (const eventName of customEvents) {
+      es.addEventListener(eventName, (event) => {
+        if (disposed) return;
+        callbacks.onEvent(eventName, event.data ?? "", void 0);
+      });
+    }
     es.addEventListener("error", (event) => {
       if (disposed) return;
       const msg = "message" in event ? String(event.message) : "";
       if (msg.includes("Channel is closed") || msg.includes("410")) {
-        callbacks.onStatusChange("closed");
-        cleanupEventSource();
+        callbacks.onClosed?.();
+        cleanup();
         disposed = true;
         return;
       }
-      if (msg) callbacks.onError(new Error(msg));
+      if (msg) callbacks.onError?.(new Error(msg));
       scheduleReconnect();
     });
     es.addEventListener("close", () => {
@@ -162,22 +143,104 @@ async function createChatSession(config, channelId, profile, callbacks) {
       scheduleReconnect();
     });
   }
-  function scheduleReconnect() {
-    if (disposed || reconnectTimer) return;
-    callbacks.onStatusChange("reconnecting");
-    cleanupEventSource();
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null;
-      connect();
-    }, reconnectDelay);
+  connect();
+  return {
+    close: () => {
+      disposed = true;
+      if (reconnectTimer) {
+        clearTimeout(reconnectTimer);
+        reconnectTimer = null;
+      }
+      cleanup();
+    }
+  };
+}
+
+// src/session.ts
+var DEFAULT_RECONNECT_DELAY_MS2 = 3e3;
+var MAX_SEEN_IDS = 500;
+async function createChatSession(config, channelId, profile, callbacks) {
+  const serviceUrl = resolveServerUrl(config.manifest, channelId);
+  const customHeaders = config.headers ?? {};
+  const reconnectDelay = config.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS2;
+  callbacks.onStatusChange("connecting");
+  const joinRes = await fetch(`${serviceUrl}/channels/${channelId}/join`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...customHeaders },
+    body: JSON.stringify(profile)
+  });
+  if (joinRes.status === 410) {
+    throw new ChannelClosedError(channelId);
   }
-  function cleanupEventSource() {
-    if (es) {
-      es.removeAllEventListeners();
-      es.close();
-      es = null;
+  if (!joinRes.ok) {
+    throw new Error(`Join failed: ${joinRes.status} ${await joinRes.text()}`);
+  }
+  const { messages, participants, joined_at } = await joinRes.json();
+  let lastEventId = messages.length > 0 ? messages[messages.length - 1].id : void 0;
+  const joinedAt = joined_at;
+  const seenMessageIds = new Set(messages.map((m) => m.id));
+  let sseConn = null;
+  let disposed = false;
+  const TRIM_THRESHOLD = MAX_SEEN_IDS * 1.5;
+  function trimSeenIds() {
+    if (seenMessageIds.size <= TRIM_THRESHOLD) return;
+    const ids = [...seenMessageIds];
+    seenMessageIds.clear();
+    for (const id of ids.slice(-MAX_SEEN_IDS)) {
+      seenMessageIds.add(id);
     }
   }
+  function connect() {
+    if (disposed) return;
+    const streamUrl = lastEventId ? `${serviceUrl}/channels/${channelId}/stream` : `${serviceUrl}/channels/${channelId}/stream?since_time=${encodeURIComponent(joinedAt)}`;
+    sseConn = createSSEConnection(
+      {
+        url: streamUrl,
+        headers: customHeaders,
+        reconnectDelayMs: reconnectDelay,
+        lastEventId,
+        customEvents: ["resync"]
+      },
+      {
+        onOpen: () => {
+          if (!disposed) callbacks.onStatusChange("connected");
+        },
+        onEvent: (eventType, data, eventId) => {
+          if (disposed) return;
+          if (eventType === "message") {
+            let message;
+            try {
+              message = JSON.parse(data);
+            } catch {
+              callbacks.onError(new Error("Failed to parse SSE message"));
+              return;
+            }
+            if (eventId) {
+              lastEventId = eventId;
+            }
+            if (seenMessageIds.has(message.id)) return;
+            seenMessageIds.add(message.id);
+            trimSeenIds();
+            callbacks.onMessage(message);
+          } else if (eventType === "resync") {
+            sseConn?.close();
+            sseConn = null;
+            callbacks.onResync();
+          }
+        },
+        onError: (err) => {
+          if (!disposed) callbacks.onError(err);
+        },
+        onClosed: () => {
+          callbacks.onStatusChange("closed");
+          disposed = true;
+        },
+        onReconnecting: () => {
+          if (!disposed) callbacks.onStatusChange("reconnecting");
+        }
+      }
+    );
+  }
   connect();
   return {
     serviceUrl,
@@ -207,13 +270,23 @@ async function createChatSession(config, channelId, profile, callbacks) {
       seenMessageIds.add(response.id);
       return response;
     },
+    markAsRead: async (messageId) => {
+      const res = await fetch(`${serviceUrl}/channels/${channelId}/read`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...customHeaders },
+        body: JSON.stringify({
+          participant_id: profile.id,
+          message_id: messageId
+        })
+      });
+      if (!res.ok) {
+        throw new Error(`markAsRead failed: ${res.status}`);
+      }
+    },
     disconnect: () => {
       disposed = true;
-      if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-      }
-      cleanupEventSource();
+      sseConn?.close();
+      sseConn = null;
       callbacks.onStatusChange("disconnected");
     }
   };
@@ -228,6 +301,8 @@ function useChat({ config, channelId, profile, onMessage }) {
   const [error, setError] = (0, import_react.useState)(null);
   const sessionRef = (0, import_react.useRef)(null);
   const disposedRef = (0, import_react.useRef)(false);
+  const messagesRef = (0, import_react.useRef)(messages);
+  messagesRef.current = messages;
   const statusRef = (0, import_react.useRef)(status);
   statusRef.current = status;
   const appStateRef = (0, import_react.useRef)(import_react_native.AppState.currentState);
@@ -245,6 +320,9 @@ function useChat({ config, channelId, profile, onMessage }) {
     onMessage: (message) => {
       if (disposedRef.current) return;
       setMessages((prev) => {
+        if (pendingOptimisticIds.current.size === 0) {
+          return [...prev, message];
+        }
         const optimisticIdx = prev.findIndex(
           (m) => pendingOptimisticIds.current.has(m.id) && m.sender_id === message.sender_id && m.body === message.body && m.type === message.type
         );
@@ -308,6 +386,13 @@ function useChat({ config, channelId, profile, onMessage }) {
     startSession();
     return () => {
       disposedRef.current = true;
+      if (statusRef.current === "connected" && sessionRef.current) {
+        const lastMsg = messagesRef.current[messagesRef.current.length - 1];
+        if (lastMsg) {
+          sessionRef.current.markAsRead(lastMsg.id).catch(() => {
+          });
+        }
+      }
       if (backgroundTimerRef.current) {
         clearTimeout(backgroundTimerRef.current);
         backgroundTimerRef.current = null;
@@ -407,13 +492,135 @@ function useChat({ config, channelId, profile, onMessage }) {
   }, []);
   return { messages, participants, status, error, sendMessage, disconnect };
 }
+
+// src/use-unread.ts
+var import_react2 = require("react");
+var import_react_native2 = require("react-native");
+var DEFAULT_BACKGROUND_GRACE_MS2 = 2e3;
+var UNREAD_CUSTOM_EVENTS = ["unread_snapshot", "unread_update", "unread_clear"];
+function useUnread(options) {
+  const { config, channelId, participantId, enabled = true } = options;
+  const [unreadCount, setUnreadCount] = (0, import_react2.useState)(0);
+  const [lastMessageAt, setLastMessageAt] = (0, import_react2.useState)(null);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const connRef = (0, import_react2.useRef)(null);
+  const configRef = (0, import_react2.useRef)(config);
+  configRef.current = config;
+  const appStateRef = (0, import_react2.useRef)(import_react_native2.AppState.currentState);
+  const backgroundTimerRef = (0, import_react2.useRef)(null);
+  const backgroundGraceMs = config.backgroundGraceMs ?? (import_react_native2.Platform.OS === "android" ? DEFAULT_BACKGROUND_GRACE_MS2 : 0);
+  const connect = (0, import_react2.useCallback)(() => {
+    connRef.current?.close();
+    connRef.current = null;
+    const serviceUrl = resolveServerUrl(configRef.current.manifest, channelId);
+    const customHeaders = configRef.current.headers ?? {};
+    const url = `${serviceUrl}/channels/${channelId}/unread?participant_id=${encodeURIComponent(participantId)}`;
+    connRef.current = createSSEConnection(
+      {
+        url,
+        headers: customHeaders,
+        reconnectDelayMs: configRef.current.reconnectDelayMs,
+        customEvents: UNREAD_CUSTOM_EVENTS
+      },
+      {
+        onOpen: () => {
+          setError(null);
+        },
+        onEvent: (eventType, data) => {
+          try {
+            if (eventType === "unread_snapshot") {
+              const snapshot = JSON.parse(data);
+              setUnreadCount(snapshot.unread_count);
+              setLastMessageAt(snapshot.last_message_at);
+            } else if (eventType === "unread_update") {
+              const update = JSON.parse(data);
+              setUnreadCount((prev) => prev + 1);
+              setLastMessageAt(update.created_at);
+            } else if (eventType === "unread_clear") {
+              const clear = JSON.parse(data);
+              setUnreadCount(clear.unread_count);
+            }
+          } catch {
+            setError(new Error("Failed to parse unread SSE event"));
+          }
+        },
+        onError: (err) => {
+          setError(err);
+        },
+        onClosed: () => {
+          connRef.current = null;
+        }
+      }
+    );
+  }, [channelId, participantId]);
+  const disconnect = (0, import_react2.useCallback)(() => {
+    connRef.current?.close();
+    connRef.current = null;
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    setUnreadCount(0);
+    setLastMessageAt(null);
+    setError(null);
+    if (!enabled) {
+      disconnect();
+      return;
+    }
+    connect();
+    return () => {
+      disconnect();
+      if (backgroundTimerRef.current) {
+        clearTimeout(backgroundTimerRef.current);
+        backgroundTimerRef.current = null;
+      }
+    };
+  }, [channelId, participantId, enabled, connect, disconnect]);
+  (0, import_react2.useEffect)(() => {
+    if (!enabled) return;
+    const subscription = import_react_native2.AppState.addEventListener("change", (nextAppState) => {
+      const prev = appStateRef.current;
+      appStateRef.current = nextAppState;
+      if (!connRef.current && nextAppState !== "active") return;
+      const shouldTeardown = nextAppState === "background" || import_react_native2.Platform.OS === "ios" && nextAppState === "inactive";
+      if (nextAppState === "active") {
+        if (backgroundTimerRef.current) {
+          clearTimeout(backgroundTimerRef.current);
+          backgroundTimerRef.current = null;
+          return;
+        }
+        if (prev.match(/inactive|background/) && !connRef.current) {
+          connect();
+        }
+      } else if (shouldTeardown) {
+        if (backgroundTimerRef.current) return;
+        if (backgroundGraceMs === 0) {
+          disconnect();
+        } else {
+          backgroundTimerRef.current = setTimeout(() => {
+            backgroundTimerRef.current = null;
+            disconnect();
+          }, backgroundGraceMs);
+        }
+      }
+    });
+    return () => {
+      subscription.remove();
+      if (backgroundTimerRef.current) {
+        clearTimeout(backgroundTimerRef.current);
+        backgroundTimerRef.current = null;
+      }
+    };
+  }, [enabled, backgroundGraceMs, connect, disconnect]);
+  return { unreadCount, hasUnread: unreadCount > 0, lastMessageAt, error };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ChannelClosedError,
   ChatDisconnectedError,
   createChatSession,
   createManifest,
+  createSSEConnection,
   resolveServerUrl,
-  useChat
+  useChat,
+  useUnread
 });
 //# sourceMappingURL=index.js.map