@pedi/chika-sdk 1.0.5 → 1.0.7

package/dist/index.mjs

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/use-chat.ts
 import { useEffect, useRef, useState, useCallback } from "react";
 import { AppState, Platform } from "react-native";
@@ -17,6 +24,104 @@ var ChannelClosedError = class extends Error {
     this.name = "ChannelClosedError";
   }
 };
+var HttpError = class extends Error {
+  constructor(status, body, retryAfter) {
+    super(`HTTP ${status}: ${body}`);
+    this.status = status;
+    this.body = body;
+    this.retryAfter = retryAfter;
+    this.name = "HttpError";
+  }
+};
+var RetryExhaustedError = class extends Error {
+  constructor(operation, attempts, lastError) {
+    super(`${operation} failed after ${attempts} attempts: ${lastError.message}`);
+    this.operation = operation;
+    this.attempts = attempts;
+    this.lastError = lastError;
+    this.name = "RetryExhaustedError";
+  }
+};
+var QueueFullError = class extends Error {
+  constructor(maxSize) {
+    super(`Message queue full (max ${maxSize})`);
+    this.maxSize = maxSize;
+    this.name = "QueueFullError";
+  }
+};
+
+// src/retry.ts
+var DEFAULT_RETRY_CONFIG = {
+  maxAttempts: 3,
+  baseDelayMs: 1e3,
+  maxDelayMs: 1e4,
+  jitterFactor: 0.3
+};
+function calculateBackoff(attempt, config) {
+  const delay = Math.min(config.baseDelayMs * 2 ** attempt, config.maxDelayMs);
+  const jitter = 1 + (Math.random() * 2 - 1) * config.jitterFactor;
+  return Math.round(delay * jitter);
+}
+function isRetryableError(error) {
+  if (error instanceof ChannelClosedError) return false;
+  if (error instanceof ChatDisconnectedError) return false;
+  if (error instanceof QueueFullError) return false;
+  if (error instanceof DOMException && error.name === "AbortError") return false;
+  if (error instanceof HttpError) {
+    const { status } = error;
+    if (status === 408 || status === 429) return true;
+    if (status >= 500) return true;
+    return false;
+  }
+  if (error instanceof TypeError) return true;
+  return false;
+}
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timer = setTimeout(resolve, ms);
+    signal?.addEventListener(
+      "abort",
+      () => {
+        clearTimeout(timer);
+        reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+function resolveRetryConfig(resilience) {
+  if (resilience === false) return null;
+  if (!resilience || resilience.retry === void 0) return DEFAULT_RETRY_CONFIG;
+  if (resilience.retry === false) return null;
+  return { ...DEFAULT_RETRY_CONFIG, ...resilience.retry };
+}
+async function withRetry(fn, config = DEFAULT_RETRY_CONFIG, signal) {
+  let lastError;
+  for (let attempt = 0; attempt < config.maxAttempts; attempt++) {
+    if (signal?.aborted) {
+      throw signal.reason ?? new DOMException("Aborted", "AbortError");
+    }
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (!isRetryableError(err)) throw lastError;
+      if (attempt < config.maxAttempts - 1) {
+        const delayMs = err instanceof HttpError && err.retryAfter != null ? err.retryAfter * 1e3 : calculateBackoff(attempt, config);
+        await sleep(delayMs, signal);
+      }
+    }
+  }
+  throw new RetryExhaustedError(
+    "operation",
+    config.maxAttempts,
+    lastError
+  );
+}
 
 // src/resolve-url.ts
 function createManifest(serverUrl) {
@@ -35,27 +140,55 @@ function resolveServerUrl(manifest, channelId) {
 import EventSource from "react-native-sse";
 var DEFAULT_RECONNECT_DELAY_MS = 3e3;
 function createSSEConnection(config, callbacks) {
-  const reconnectDelay = config.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+  const baseDelay = config.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
   const customEvents = config.customEvents ?? [];
+  const monitor = config.networkMonitor;
+  const backoffConfig = {
+    maxAttempts: Infinity,
+    baseDelayMs: baseDelay,
+    maxDelayMs: 3e4,
+    jitterFactor: 0.3
+  };
   let currentLastEventId = config.lastEventId;
   let es = null;
   let disposed = false;
   let reconnectTimer = null;
+  let attempt = 0;
+  let waitAbort = null;
   function cleanup() {
     if (es) {
       es.removeAllEventListeners();
       es.close();
       es = null;
     }
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    if (waitAbort) {
+      waitAbort.abort();
+      waitAbort = null;
+    }
   }
-  function scheduleReconnect() {
-    if (disposed || reconnectTimer) return;
+  async function scheduleReconnect() {
+    if (disposed || reconnectTimer || waitAbort) return;
     callbacks.onReconnecting?.();
     cleanup();
+    if (monitor && !monitor.isConnected()) {
+      waitAbort = new AbortController();
+      try {
+        await monitor.waitForOnline(waitAbort.signal);
+      } catch {
+        return;
+      }
+      waitAbort = null;
+      if (disposed) return;
+    }
+    const delay = calculateBackoff(attempt++, backoffConfig);
     reconnectTimer = setTimeout(() => {
       reconnectTimer = null;
       connect();
-    }, reconnectDelay);
+    }, delay);
   }
   function connect() {
     if (disposed) return;
@@ -68,6 +201,7 @@ function createSSEConnection(config, callbacks) {
     });
     es.addEventListener("open", () => {
       if (disposed) return;
+      attempt = 0;
       callbacks.onOpen?.();
     });
     es.addEventListener("message", (event) => {
@@ -104,11 +238,13 @@ function createSSEConnection(config, callbacks) {
   return {
     close: () => {
       disposed = true;
-      if (reconnectTimer) {
-        clearTimeout(reconnectTimer);
-        reconnectTimer = null;
-      }
       cleanup();
+    },
+    reconnectImmediate: () => {
+      if (disposed) return;
+      cleanup();
+      attempt = 0;
+      connect();
     }
   };
 }
@@ -116,23 +252,46 @@ function createSSEConnection(config, callbacks) {
 // src/session.ts
 var DEFAULT_RECONNECT_DELAY_MS2 = 3e3;
 var MAX_SEEN_IDS = 500;
-async function createChatSession(config, channelId, profile, callbacks) {
+var MARK_READ_RETRY_CONFIG = {
+  maxAttempts: 2,
+  baseDelayMs: 500,
+  maxDelayMs: 2e3,
+  jitterFactor: 0.3
+};
+function parseRetryAfter(res) {
+  const header = res.headers.get("Retry-After");
+  if (!header) return void 0;
+  const seconds = Number(header);
+  return Number.isFinite(seconds) ? seconds : void 0;
+}
+async function throwHttpError(res) {
+  const body = await res.text().catch(() => "");
+  throw new HttpError(res.status, body, parseRetryAfter(res));
+}
+async function createChatSession(config, channelId, profile, callbacks, networkMonitor) {
   const serviceUrl = resolveServerUrl(config.manifest, channelId);
   const customHeaders = config.headers ?? {};
   const reconnectDelay = config.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS2;
+  const retryConfig = resolveRetryConfig(config.resilience);
+  const sessionAbort = new AbortController();
   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();
+  const joinFn = async () => {
+    const joinRes = await fetch(`${serviceUrl}/channels/${channelId}/join`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", ...customHeaders },
+      body: JSON.stringify(profile),
+      signal: sessionAbort.signal
+    });
+    if (joinRes.status === 410) {
+      throw new ChannelClosedError(channelId);
+    }
+    if (!joinRes.ok) {
+      await throwHttpError(joinRes);
+    }
+    return joinRes.json();
+  };
+  const joinData = retryConfig ? await withRetry(joinFn, retryConfig, sessionAbort.signal) : await joinFn();
+  const { messages, participants, joined_at } = joinData;
   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));
@@ -156,7 +315,8 @@ async function createChatSession(config, channelId, profile, callbacks) {
         headers: customHeaders,
         reconnectDelayMs: reconnectDelay,
         lastEventId,
-        customEvents: ["resync"]
+        customEvents: ["resync"],
+        networkMonitor
       },
       {
         onOpen: () => {
@@ -180,8 +340,6 @@ async function createChatSession(config, channelId, profile, callbacks) {
             trimSeenIds();
             callbacks.onMessage(message);
           } else if (eventType === "resync") {
-            sseConn?.close();
-            sseConn = null;
             callbacks.onResync();
           }
         },
@@ -204,44 +362,65 @@ async function createChatSession(config, channelId, profile, callbacks) {
     channelId,
     initialParticipants: participants,
     initialMessages: messages,
-    sendMessage: async (type, body, attributes) => {
+    networkMonitor: networkMonitor ?? null,
+    sendMessage: async (type, body, attributes, idempotencyKey) => {
       if (disposed) throw new ChatDisconnectedError("disconnected");
       const payload = {
         sender_id: profile.id,
         type,
         body,
-        attributes
+        attributes,
+        ...idempotencyKey ? { idempotency_key: idempotencyKey } : {}
       };
-      const res = await fetch(
-        `${serviceUrl}/channels/${channelId}/messages`,
-        {
-          method: "POST",
-          headers: { "Content-Type": "application/json", ...customHeaders },
-          body: JSON.stringify(payload)
+      const sendFn = async () => {
+        const res = await fetch(
+          `${serviceUrl}/channels/${channelId}/messages`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json", ...customHeaders },
+            body: JSON.stringify(payload),
+            signal: sessionAbort.signal
+          }
+        );
+        if (!res.ok) {
+          await throwHttpError(res);
         }
-      );
-      if (!res.ok) {
-        throw new Error(`Send failed: ${res.status} ${await res.text()}`);
-      }
-      const response = await res.json();
+        return res.json();
+      };
+      const response = retryConfig ? await withRetry(sendFn, retryConfig, sessionAbort.signal) : await sendFn();
       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}`);
+      const readFn = async () => {
+        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
+          }),
+          signal: sessionAbort.signal
+        });
+        if (!res.ok) {
+          await throwHttpError(res);
+        }
+      };
+      if (retryConfig) {
+        try {
+          await withRetry(readFn, MARK_READ_RETRY_CONFIG, sessionAbort.signal);
+        } catch (err) {
+          if (err instanceof HttpError) {
+            callbacks.onError(err);
+          }
+        }
+      } else {
+        await readFn();
       }
     },
     disconnect: () => {
       disposed = true;
+      sessionAbort.abort();
       sseConn?.close();
       sseConn = null;
       callbacks.onStatusChange("disconnected");
@@ -249,13 +428,342 @@ async function createChatSession(config, channelId, profile, callbacks) {
   };
 }
 
+// src/network-monitor.ts
+function createStubMonitor() {
+  return {
+    isConnected: () => true,
+    subscribe: () => () => {
+    },
+    waitForOnline: () => Promise.resolve(),
+    dispose: () => {
+    }
+  };
+}
+var resolvedNetInfo = void 0;
+var netInfoResolved = false;
+function getNetInfo() {
+  if (netInfoResolved) return resolvedNetInfo;
+  netInfoResolved = true;
+  try {
+    resolvedNetInfo = __require("@react-native-community/netinfo");
+  } catch {
+    resolvedNetInfo = null;
+  }
+  return resolvedNetInfo;
+}
+function createNetworkMonitor() {
+  const NetInfo = getNetInfo();
+  if (!NetInfo) return createStubMonitor();
+  const netInfoModule = NetInfo.default ?? NetInfo;
+  let connected = true;
+  const listeners = /* @__PURE__ */ new Set();
+  let unsubscribeNetInfo = null;
+  unsubscribeNetInfo = netInfoModule.addEventListener(
+    (state) => {
+      const next = state.isConnected !== false;
+      if (next === connected) return;
+      connected = next;
+      for (const cb of listeners) {
+        cb(connected);
+      }
+    }
+  );
+  return {
+    isConnected: () => connected,
+    subscribe: (cb) => {
+      listeners.add(cb);
+      return () => {
+        listeners.delete(cb);
+      };
+    },
+    waitForOnline: (signal) => {
+      if (connected) return Promise.resolve();
+      return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+          reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+          return;
+        }
+        const unsub = () => {
+          listeners.delete(handler);
+          signal?.removeEventListener("abort", onAbort);
+        };
+        const handler = (isOnline) => {
+          if (isOnline) {
+            unsub();
+            resolve();
+          }
+        };
+        const onAbort = () => {
+          unsub();
+          reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+        };
+        listeners.add(handler);
+        signal?.addEventListener("abort", onAbort, { once: true });
+      });
+    },
+    dispose: () => {
+      listeners.clear();
+      unsubscribeNetInfo?.();
+      unsubscribeNetInfo = null;
+    }
+  };
+}
+
+// src/message-queue.ts
+var resolvedStorage;
+function tryRequire(name) {
+  try {
+    return __require(name);
+  } catch {
+    return null;
+  }
+}
+function createMmkvAdapter(mod) {
+  const MMKV = mod.MMKV ?? mod.default?.MMKV ?? mod;
+  const instance = new MMKV({ id: "chika-queue" });
+  return {
+    getItem: (key) => Promise.resolve(instance.getString(key) ?? null),
+    setItem: (key, value) => {
+      instance.set(key, value);
+      return Promise.resolve();
+    },
+    removeItem: (key) => {
+      instance.delete(key);
+      return Promise.resolve();
+    }
+  };
+}
+function createAsyncStorageAdapterFrom(mod) {
+  const storage = mod.default ?? mod;
+  return {
+    getItem: (key) => storage.getItem(key),
+    setItem: (key, value) => storage.setItem(key, value),
+    removeItem: (key) => storage.removeItem(key)
+  };
+}
+function createQueueStorage() {
+  if (resolvedStorage !== void 0) return resolvedStorage?.adapter ?? null;
+  const mmkv = tryRequire("react-native-mmkv");
+  if (mmkv) {
+    try {
+      const adapter = createMmkvAdapter(mmkv);
+      resolvedStorage = { type: "mmkv", adapter };
+      return adapter;
+    } catch {
+    }
+  }
+  const asyncStorage = tryRequire("@react-native-async-storage/async-storage");
+  if (asyncStorage) {
+    const adapter = createAsyncStorageAdapterFrom(asyncStorage);
+    resolvedStorage = { type: "async-storage", adapter };
+    return adapter;
+  }
+  resolvedStorage = null;
+  return null;
+}
+function createAsyncStorageAdapter() {
+  const mod = tryRequire("@react-native-async-storage/async-storage");
+  if (!mod) return null;
+  return createAsyncStorageAdapterFrom(mod);
+}
+var MessageQueue = class {
+  constructor(config) {
+    this.config = config;
+    this.storageKey = `chika_queue_${config.channelId}`;
+    this.unsubNetwork = config.networkMonitor.subscribe((connected) => {
+      if (connected) this.flush();
+    });
+  }
+  entries = [];
+  flushing = false;
+  unsubNetwork = null;
+  storageKey;
+  /**
+   * Restore queued messages from persistent storage on cold start.
+   * Restored entries are fire-and-forget — there is no caller awaiting their
+   * promise (the original enqueue() caller is gone after app restart).
+   * Success/failure is reported via onStatusChange/onError callbacks.
+   */
+  async restore(rebuildSendFn) {
+    if (!this.config.storage) return;
+    try {
+      const raw = await this.config.storage.getItem(this.storageKey);
+      if (!raw) return;
+      const persisted = JSON.parse(raw);
+      for (const entry of persisted) {
+        const sendFn = rebuildSendFn(entry.optimisticId);
+        if (!sendFn) continue;
+        const abort = new AbortController();
+        this.entries.push({
+          optimisticId: entry.optimisticId,
+          sendFn,
+          status: "queued",
+          retryCount: entry.retryCount,
+          abort,
+          // No-op: restored entries have no caller awaiting the promise.
+          resolve: () => {
+          },
+          reject: () => {
+          }
+        });
+      }
+      if (this.entries.length > 0) {
+        this.config.onStatusChange?.();
+        this.flush();
+      }
+    } catch {
+      this.config.onError?.(new Error("Failed to restore message queue from storage"));
+    }
+  }
+  get pendingCount() {
+    return this.entries.length;
+  }
+  getAll() {
+    return this.entries.map((e) => ({
+      optimisticId: e.optimisticId,
+      status: e.status,
+      error: e.error,
+      retryCount: e.retryCount
+    }));
+  }
+  getStatus(optimisticId) {
+    const entry = this.entries.find((e) => e.optimisticId === optimisticId);
+    if (!entry) return void 0;
+    return {
+      optimisticId: entry.optimisticId,
+      status: entry.status,
+      error: entry.error,
+      retryCount: entry.retryCount
+    };
+  }
+  enqueue(sendFn, optimisticId) {
+    if (this.entries.length >= this.config.maxSize) {
+      throw new QueueFullError(this.config.maxSize);
+    }
+    const abort = new AbortController();
+    return new Promise((resolve, reject) => {
+      const entry = {
+        optimisticId,
+        sendFn,
+        status: "queued",
+        retryCount: 0,
+        abort,
+        resolve,
+        reject
+      };
+      this.entries.push(entry);
+      this.config.onStatusChange?.();
+      this.persist();
+      this.flush();
+    });
+  }
+  cancel(optimisticId) {
+    const idx = this.entries.findIndex((e) => e.optimisticId === optimisticId);
+    if (idx === -1) return;
+    const entry = this.entries[idx];
+    entry.abort.abort();
+    entry.reject(new DOMException("Cancelled", "AbortError"));
+    this.entries.splice(idx, 1);
+    this.config.onStatusChange?.();
+    this.persist();
+  }
+  retry(optimisticId) {
+    const entry = this.entries.find((e) => e.optimisticId === optimisticId);
+    if (!entry || entry.status !== "failed") return;
+    entry.status = "queued";
+    entry.error = void 0;
+    entry.abort = new AbortController();
+    this.config.onStatusChange?.();
+    this.flush();
+  }
+  dispose() {
+    this.unsubNetwork?.();
+    this.unsubNetwork = null;
+    for (const entry of this.entries) {
+      entry.abort.abort();
+      entry.reject(new DOMException("Queue disposed", "AbortError"));
+    }
+    this.entries = [];
+  }
+  /**
+   * Trigger a flush of queued messages. Returns immediately if a flush is
+   * already in progress or the network is offline. The in-progress flush
+   * will pick up any newly queued entries via its while loop.
+   */
+  async flush() {
+    if (this.flushing) return;
+    if (!this.config.networkMonitor.isConnected()) return;
+    this.flushing = true;
+    let awaitingSession = false;
+    try {
+      while (this.entries.length > 0) {
+        const entry = this.entries.find((e) => e.status === "queued");
+        if (!entry) break;
+        if (!this.config.networkMonitor.isConnected()) break;
+        entry.status = "sending";
+        this.config.onStatusChange?.();
+        try {
+          const result = await withRetry(
+            entry.sendFn,
+            this.config.retryConfig,
+            entry.abort.signal
+          );
+          entry.resolve(result);
+          const idx = this.entries.indexOf(entry);
+          if (idx !== -1) this.entries.splice(idx, 1);
+          this.config.onStatusChange?.();
+          this.persist();
+        } catch (err) {
+          if (entry.abort.signal.aborted) continue;
+          if (err instanceof ChatDisconnectedError) {
+            entry.status = "queued";
+            this.config.onStatusChange?.();
+            awaitingSession = true;
+            break;
+          }
+          entry.status = "failed";
+          entry.error = err instanceof Error ? err : new Error(String(err));
+          entry.retryCount++;
+          this.config.onStatusChange?.();
+          this.persist();
+        }
+      }
+    } finally {
+      this.flushing = false;
+      if (!awaitingSession && this.entries.some((e) => e.status === "queued") && this.config.networkMonitor.isConnected()) {
+        queueMicrotask(() => this.flush());
+      }
+    }
+  }
+  persist() {
+    if (!this.config.storage) return;
+    const data = this.entries.map((e) => ({
+      optimisticId: e.optimisticId,
+      retryCount: e.retryCount
+    }));
+    const onErr = (err) => {
+      this.config.onError?.(
+        err instanceof Error ? err : new Error("Queue storage write failed")
+      );
+    };
+    if (data.length === 0) {
+      this.config.storage.removeItem(this.storageKey).catch(onErr);
+    } else {
+      this.config.storage.setItem(this.storageKey, JSON.stringify(data)).catch(onErr);
+    }
+  }
+};
+
 // src/use-chat.ts
 var DEFAULT_BACKGROUND_GRACE_MS = 2e3;
+var DEFAULT_MAX_QUEUE_SIZE = 50;
+var queueRegistry = /* @__PURE__ */ new Map();
 function useChat({ config, channelId, profile, onMessage }) {
   const [messages, setMessages] = useState([]);
   const [participants, setParticipants] = useState([]);
   const [status, setStatus] = useState("connecting");
   const [error, setError] = useState(null);
+  const [pendingMessages, setPendingMessages] = useState([]);
   const sessionRef = useRef(null);
   const disposedRef = useRef(false);
   const messagesRef = useRef(messages);
@@ -272,10 +780,36 @@ function useChat({ config, channelId, profile, onMessage }) {
   onMessageRef.current = onMessage;
   const startingRef = useRef(false);
   const pendingOptimisticIds = useRef(/* @__PURE__ */ new Set());
+  const [monitor, setMonitor] = useState(null);
+  const monitorRef = useRef(null);
+  monitorRef.current = monitor;
+  const queueRef = useRef(null);
+  const resilienceEnabled = config.resilience !== false;
+  const queueEnabled = resilienceEnabled && (typeof config.resilience === "object" ? config.resilience.offlineQueue !== false : true);
+  const retryConfig = resolveRetryConfig(config.resilience);
+  const maxQueueSize = (resilienceEnabled && config.resilience && typeof config.resilience === "object" ? config.resilience.maxQueueSize : void 0) ?? DEFAULT_MAX_QUEUE_SIZE;
   const backgroundGraceMs = config.backgroundGraceMs ?? (Platform.OS === "android" ? DEFAULT_BACKGROUND_GRACE_MS : 0);
+  const injectedMonitor = typeof config.resilience === "object" ? config.resilience.networkMonitor : void 0;
+  useEffect(() => {
+    if (!resilienceEnabled) {
+      setMonitor(null);
+      return;
+    }
+    if (injectedMonitor) {
+      setMonitor(injectedMonitor);
+      return;
+    }
+    const m = createNetworkMonitor();
+    setMonitor(m);
+    return () => {
+      m.dispose();
+      setMonitor(null);
+    };
+  }, [resilienceEnabled, injectedMonitor]);
   const callbacks = {
     onMessage: (message) => {
       if (disposedRef.current) return;
+      let matchedOptimisticId = null;
       setMessages((prev) => {
         if (pendingOptimisticIds.current.size === 0) {
           return [...prev, message];
@@ -284,20 +818,28 @@ function useChat({ config, channelId, profile, onMessage }) {
           (m) => pendingOptimisticIds.current.has(m.id) && m.sender_id === message.sender_id && m.body === message.body && m.type === message.type
         );
         if (optimisticIdx !== -1) {
-          const optimisticId = prev[optimisticIdx].id;
-          pendingOptimisticIds.current.delete(optimisticId);
+          matchedOptimisticId = prev[optimisticIdx].id;
+          pendingOptimisticIds.current.delete(matchedOptimisticId);
           const next = [...prev];
           next[optimisticIdx] = message;
           return next;
         }
         return [...prev, message];
       });
+      if (matchedOptimisticId) {
+        const s = queueRef.current?.getStatus(matchedOptimisticId);
+        if (s && s.status !== "sending") {
+          queueRef.current?.cancel(matchedOptimisticId);
+        }
+      }
       onMessageRef.current?.(message);
     },
     onStatusChange: (nextStatus) => {
       if (disposedRef.current) return;
       setStatus(nextStatus);
-      if (nextStatus === "connected") setError(null);
+      if (nextStatus === "connected") {
+        setError(null);
+      }
     },
     onError: (err) => {
       if (disposedRef.current) return;
@@ -317,14 +859,29 @@ function useChat({ config, channelId, profile, onMessage }) {
       sessionRef.current = null;
     }
     try {
-      const session = await createChatSession(configRef.current, channelId, profileRef.current, callbacks);
+      const session = await createChatSession(
+        configRef.current,
+        channelId,
+        profileRef.current,
+        callbacks,
+        monitorRef.current ?? void 0
+      );
       if (disposedRef.current) {
         session.disconnect();
         return;
       }
       sessionRef.current = session;
       setParticipants(session.initialParticipants);
-      setMessages(session.initialMessages);
+      queueRef.current?.flush();
+      if (pendingOptimisticIds.current.size > 0) {
+        const pendingIds = pendingOptimisticIds.current;
+        setMessages((prev) => {
+          const pendingMsgs = prev.filter((m) => pendingIds.has(m.id));
+          return [...session.initialMessages, ...pendingMsgs];
+        });
+      } else {
+        setMessages(session.initialMessages);
+      }
     } catch (err) {
       if (disposedRef.current) return;
       if (err instanceof ChannelClosedError) {
@@ -340,6 +897,7 @@ function useChat({ config, channelId, profile, onMessage }) {
   }
   useEffect(() => {
     disposedRef.current = false;
+    if (resilienceEnabled && !monitor) return;
     startSession();
     return () => {
       disposedRef.current = true;
@@ -357,7 +915,52 @@ function useChat({ config, channelId, profile, onMessage }) {
       sessionRef.current?.disconnect();
       sessionRef.current = null;
     };
-  }, [channelId]);
+  }, [channelId, monitor]);
+  useEffect(() => {
+    if (!queueEnabled || !monitor || !retryConfig) return;
+    let entry = queueRegistry.get(channelId);
+    if (!entry) {
+      const queue = new MessageQueue({
+        channelId,
+        maxSize: maxQueueSize,
+        retryConfig,
+        networkMonitor: monitor,
+        storage: typeof config.resilience === "object" ? config.resilience.queueStorage : void 0,
+        onError: (err) => {
+          if (!disposedRef.current) setError(err);
+        },
+        onStatusChange: () => {
+          if (!disposedRef.current) {
+            setPendingMessages(queueRef.current?.getAll() ?? []);
+          }
+        }
+      });
+      entry = { queue, refCount: 0 };
+      queueRegistry.set(channelId, entry);
+    }
+    entry.refCount++;
+    queueRef.current = entry.queue;
+    return () => {
+      const e = queueRegistry.get(channelId);
+      if (e) {
+        e.refCount--;
+        if (e.refCount <= 0) {
+          e.queue.dispose();
+          queueRegistry.delete(channelId);
+        }
+      }
+      queueRef.current = null;
+    };
+  }, [channelId, queueEnabled, monitor]);
+  useEffect(() => {
+    if (!monitor || !resilienceEnabled) return;
+    const unsub = monitor.subscribe((connected) => {
+      if (connected && statusRef.current === "error" && !startingRef.current) {
+        startSession();
+      }
+    });
+    return unsub;
+  }, [channelId, resilienceEnabled, monitor]);
   useEffect(() => {
     function teardownSession() {
       sessionRef.current?.disconnect();
@@ -403,12 +1006,11 @@ function useChat({ config, channelId, profile, onMessage }) {
       const session = sessionRef.current;
       if (!session) throw new ChatDisconnectedError(statusRef.current);
       const optimistic = configRef.current.optimisticSend !== false;
-      let optimisticId = null;
+      const messageKey = `optimistic_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
       if (optimistic) {
-        optimisticId = `optimistic_${Date.now()}_${Math.random().toString(36).slice(2, 7)}`;
-        pendingOptimisticIds.current.add(optimisticId);
+        pendingOptimisticIds.current.add(messageKey);
         const provisionalMsg = {
-          id: optimisticId,
+          id: messageKey,
           channel_id: channelId,
           sender_id: profileRef.current.id,
           sender_role: profileRef.current.role,
@@ -419,35 +1021,91 @@ function useChat({ config, channelId, profile, onMessage }) {
         };
         setMessages((prev) => [...prev, provisionalMsg]);
       }
-      try {
-        const response = await session.sendMessage(type, body, attributes);
-        if (optimistic && optimisticId) {
-          pendingOptimisticIds.current.delete(optimisticId);
+      const doSend = () => {
+        const s = sessionRef.current;
+        if (!s) throw new ChatDisconnectedError(statusRef.current);
+        return s.sendMessage(type, body, attributes, messageKey);
+      };
+      const handleSuccess = (response) => {
+        if (optimistic) {
+          pendingOptimisticIds.current.delete(messageKey);
           setMessages((prev) => {
-            const stillPending = prev.some((m) => m.id === optimisticId);
+            const stillPending = prev.some((m) => m.id === messageKey);
             if (!stillPending) return prev;
             return prev.map(
-              (m) => m.id === optimisticId ? { ...m, id: response.id, created_at: response.created_at } : m
+              (m) => m.id === messageKey ? { ...m, id: response.id, created_at: response.created_at } : m
             );
           });
         }
+      };
+      const handleError = (_err) => {
+        if (optimistic) {
+          pendingOptimisticIds.current.delete(messageKey);
+          setMessages((prev) => prev.filter((m) => m.id !== messageKey));
+        }
+      };
+      if (queueRef.current) {
+        try {
+          const response = await queueRef.current.enqueue(doSend, messageKey);
+          handleSuccess(response);
+          return response;
+        } catch (err) {
+          if (err instanceof QueueFullError) {
+            handleError(err);
+            throw err;
+          }
+          if (err instanceof RetryExhaustedError || !isRetryableError(err)) {
+            if (optimistic && err instanceof RetryExhaustedError) {
+            } else {
+              handleError(err);
+            }
+            throw err;
+          }
+          handleError(err);
+          throw err;
+        }
+      }
+      try {
+        const response = await doSend();
+        handleSuccess(response);
         return response;
       } catch (err) {
-        if (optimistic && optimisticId) {
-          pendingOptimisticIds.current.delete(optimisticId);
-          setMessages((prev) => prev.filter((m) => m.id !== optimisticId));
-        }
+        handleError(err);
         throw err;
       }
     },
     [channelId]
   );
+  const cancelMessage = useCallback(
+    (optimisticId) => {
+      queueRef.current?.cancel(optimisticId);
+      pendingOptimisticIds.current.delete(optimisticId);
+      setMessages((prev) => prev.filter((m) => m.id !== optimisticId));
+    },
+    []
+  );
+  const retryMessage = useCallback(
+    (optimisticId) => {
+      queueRef.current?.retry(optimisticId);
+    },
+    []
+  );
   const disconnect = useCallback(() => {
     sessionRef.current?.disconnect();
     sessionRef.current = null;
     setStatus("disconnected");
   }, []);
-  return { messages, participants, status, error, sendMessage, disconnect };
+  return {
+    messages,
+    participants,
+    status,
+    error,
+    sendMessage,
+    disconnect,
+    pendingMessages,
+    cancelMessage,
+    retryMessage
+  };
 }
 
 // src/use-unread.ts
@@ -466,6 +1124,25 @@ function useUnread(options) {
   const appStateRef = useRef2(AppState2.currentState);
   const backgroundTimerRef = useRef2(null);
   const backgroundGraceMs = config.backgroundGraceMs ?? (Platform2.OS === "android" ? DEFAULT_BACKGROUND_GRACE_MS2 : 0);
+  const [monitor, setMonitor] = useState2(null);
+  const resilienceEnabled = config.resilience !== false;
+  const injectedMonitor = typeof config.resilience === "object" ? config.resilience.networkMonitor : void 0;
+  useEffect2(() => {
+    if (!resilienceEnabled) {
+      setMonitor(null);
+      return;
+    }
+    if (injectedMonitor) {
+      setMonitor(injectedMonitor);
+      return;
+    }
+    const m = createNetworkMonitor();
+    setMonitor(m);
+    return () => {
+      m.dispose();
+      setMonitor(null);
+    };
+  }, [resilienceEnabled, injectedMonitor]);
   const connect = useCallback2(() => {
     connRef.current?.close();
     connRef.current = null;
@@ -477,7 +1154,8 @@ function useUnread(options) {
         url,
         headers: customHeaders,
         reconnectDelayMs: configRef.current.reconnectDelayMs,
-        customEvents: UNREAD_CUSTOM_EVENTS
+        customEvents: UNREAD_CUSTOM_EVENTS,
+        networkMonitor: monitor ?? void 0
       },
       {
         onOpen: () => {
@@ -509,7 +1187,7 @@ function useUnread(options) {
         }
       }
     );
-  }, [channelId, participantId]);
+  }, [channelId, participantId, monitor]);
   const disconnect = useCallback2(() => {
     connRef.current?.close();
     connRef.current = null;
@@ -522,6 +1200,7 @@ function useUnread(options) {
       disconnect();
       return;
     }
+    if (resilienceEnabled && !monitor) return;
     connect();
     return () => {
       disconnect();
@@ -572,11 +1251,21 @@ function useUnread(options) {
 export {
   ChannelClosedError,
   ChatDisconnectedError,
+  HttpError,
+  QueueFullError,
+  RetryExhaustedError,
+  calculateBackoff,
+  createAsyncStorageAdapter,
   createChatSession,
   createManifest,
+  createNetworkMonitor,
+  createQueueStorage,
   createSSEConnection,
+  isRetryableError,
+  resolveRetryConfig,
   resolveServerUrl,
   useChat,
-  useUnread
+  useUnread,
+  withRetry
 };
 //# sourceMappingURL=index.mjs.map