@chromahq/react 1.0.35 → 1.0.39

package/dist/index.d.ts

@@ -8,6 +8,12 @@ interface Bridge {
     off: (key: string, handler: (payload: unknown) => void) => void;
     isConnected: boolean;
     ping: () => Promise<boolean>;
+    /**
+     * Pause health checks for the specified duration.
+     * Use this before calling a message that triggers heavy/blocking operations in the SW.
+     * @param durationMs - How long to pause health checks in milliseconds
+     */
+    pauseHealthChecks: (durationMs: number) => void;
 }
 interface BridgeContextValue {
     bridge: Bridge | null;
@@ -26,23 +32,19 @@ interface BridgeProviderProps {
     pingInterval?: number;
     /** How long to wait before resetting retry count in ms. Default: 30000 */
     maxRetryCooldown?: number;
-    /** Default timeout for messages in ms. Default: 10000 */
+    /** Default timeout for messages in ms. Default: 30000 */
     defaultTimeout?: number;
+    /**
+     * Timeout threshold for counting failures toward reconnection.
+     * Only requests with timeouts <= this value are counted as potential SW issues.
+     * Requests with longer timeouts (intentional slow operations) won't trigger reconnection.
+     * Default: 15000 (15s)
+     */
+    timeoutFailureThreshold?: number;
     /** Callback when connection status changes */
     onConnectionChange?: (status: ConnectionStatus) => void;
     /** Callback when an error occurs */
     onError?: (error: Error) => void;
-    /**
-     * Optional function to check if health checks should be paused.
-     * Return a timestamp (ms) until which health checks are paused, or null/0 if not paused.
-     * This allows service workers to pause health monitoring during heavy operations.
-     *
-     * @example
-     * ```tsx
-     * <BridgeProvider isHealthPaused={() => store.getState().healthPausedUntil}>
-     * ```
-     */
-    isHealthPausedUntil?: () => number | null | undefined;
 }
 declare const BridgeProvider: FC<BridgeProviderProps>;
 

package/dist/index.js

@@ -5,22 +5,26 @@ const BRIDGE_ENABLE_LOGS = true;
 const CONFIG = {
   RETRY_AFTER: 1e3,
   MAX_RETRIES: 10,
-  PING_INTERVAL: 3e3,
-  // Check every 3s (balance between responsiveness and false positives)
+  PING_INTERVAL: 5e3,
+  // Check every 5s (reduced frequency to avoid false positives during heavy operations)
   MAX_RETRY_COOLDOWN: 3e4,
-  DEFAULT_TIMEOUT: 1e4,
+  DEFAULT_TIMEOUT: 3e4,
+  // Increased from 20s to 30s for slow operations
   MAX_RETRY_DELAY: 3e4,
-  PING_TIMEOUT: 5e3,
-  // Give SW 5s to respond (handles busy periods)
+  PING_TIMEOUT: 1e4,
+  // Give SW 10s to respond (handles busy periods like large storage reads)
   ERROR_CHECK_INTERVAL: 100,
   MAX_ERROR_CHECKS: 10,
-  CONSECUTIVE_FAILURE_THRESHOLD: 3,
-  // Require 3 consecutive failures (9s total) before reconnecting
+  CONSECUTIVE_FAILURE_THRESHOLD: 5,
+  // Require 5 consecutive failures (25s total) before reconnecting
   RECONNECT_DELAY: 100,
   PORT_NAME: "chroma-bridge",
   // Service worker restart retry settings (indefinite retries)
   SW_RESTART_RETRY_DELAY: 500,
-  SW_RESTART_MAX_DELAY: 5e3
+  SW_RESTART_MAX_DELAY: 5e3,
+  // Threshold for counting timeouts toward reconnection (only count fast timeouts as failures)
+  TIMEOUT_FAILURE_THRESHOLD_MS: 15e3
+  // Only count timeouts < 15s as potential SW issues
 };
 const calculateBackoffDelay = (attempt, baseDelay, maxDelay) => Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
 const clearTimeoutSafe = (ref) => {
@@ -50,15 +54,19 @@ function createBridgeInstance(deps) {
     isConnectedRef,
     consecutiveTimeoutsRef,
     reconnectionGracePeriodRef,
+    healthPausedUntilRef,
     defaultTimeout,
+    timeoutFailureThreshold,
     onReconnectNeeded
   } = deps;
   const rejectAllPending = (message) => {
-    pendingRequestsRef.current.forEach(({ reject, timeout }) => {
-      clearTimeout(timeout);
-      reject(new Error(message));
+    pendingRequestsRef.current.forEach(({ reject, timeout, timeoutDuration }, id) => {
+      if (timeoutDuration <= timeoutFailureThreshold) {
+        clearTimeout(timeout);
+        reject(new Error(message));
+        pendingRequestsRef.current.delete(id);
+      }
     });
-    pendingRequestsRef.current.clear();
   };
   const send = (key, payload, timeoutDuration = defaultTimeout) => {
     return new Promise((resolve, reject) => {
@@ -70,15 +78,16 @@ function createBridgeInstance(deps) {
       const timeout = setTimeout(() => {
         if (!pendingRequestsRef.current.has(id)) return;
         pendingRequestsRef.current.delete(id);
-        if (!reconnectionGracePeriodRef.current) {
+        const isShortTimeout = timeoutDuration <= timeoutFailureThreshold;
+        if (!reconnectionGracePeriodRef.current && isShortTimeout) {
           consecutiveTimeoutsRef.current++;
         }
         {
           console.warn(
-            `[Bridge] Request timed out: ${key} (${timeoutDuration}ms)${reconnectionGracePeriodRef.current ? " [grace period]" : ""}`
+            `[Bridge] Request timed out: ${key} (${timeoutDuration}ms)${reconnectionGracePeriodRef.current ? " [grace period]" : ""}${!isShortTimeout ? " [long operation, not counted toward reconnect]" : ""}`
           );
         }
-        if (!reconnectionGracePeriodRef.current && consecutiveTimeoutsRef.current >= CONFIG.CONSECUTIVE_FAILURE_THRESHOLD) {
+        if (!reconnectionGracePeriodRef.current && isShortTimeout && consecutiveTimeoutsRef.current >= CONFIG.CONSECUTIVE_FAILURE_THRESHOLD) {
           {
             console.warn(
               `[Bridge] ${consecutiveTimeoutsRef.current} consecutive timeouts, reconnecting...`
@@ -93,7 +102,8 @@ function createBridgeInstance(deps) {
       pendingRequestsRef.current.set(id, {
         resolve,
         reject,
-        timeout
+        timeout,
+        timeoutDuration
       });
       try {
         portRef.current.postMessage({ id, key, payload });
@@ -167,6 +177,13 @@ function createBridgeInstance(deps) {
       } catch {
         return false;
       }
+    },
+    pauseHealthChecks: (durationMs) => {
+      const pauseUntil = Date.now() + durationMs;
+      healthPausedUntilRef.current = pauseUntil;
+      {
+        console.log(`[Bridge] Health checks paused for ${Math.round(durationMs / 1e3)}s`);
+      }
     }
   };
   return bridge;
@@ -176,11 +193,11 @@ function startHealthMonitor(deps) {
     bridge,
     pingIntervalRef,
     consecutivePingFailuresRef,
+    healthPausedUntilRef,
     pingInterval,
     setIsServiceWorkerAlive,
     onReconnectNeeded,
-    rejectAllPendingRequests,
-    isHealthPausedUntil
+    rejectAllPendingRequests
   } = deps;
   clearIntervalSafe(pingIntervalRef);
   consecutivePingFailuresRef.current = 0;
@@ -194,7 +211,7 @@ function startHealthMonitor(deps) {
       }
       return;
     }
-    const pausedUntil = isHealthPausedUntil?.() ?? 0;
+    const pausedUntil = healthPausedUntilRef.current;
     if (pausedUntil && Date.now() < pausedUntil) {
       {
         const remainingMs = pausedUntil - Date.now();
@@ -207,7 +224,7 @@ function startHealthMonitor(deps) {
     }
     const alive = await bridge.ping();
     if (!pingIntervalRef.current) return;
-    const pausedUntilAfterPing = isHealthPausedUntil?.() ?? 0;
+    const pausedUntilAfterPing = healthPausedUntilRef.current;
     if (pausedUntilAfterPing && Date.now() < pausedUntilAfterPing) {
       consecutivePingFailuresRef.current = 0;
       return;
@@ -240,9 +257,9 @@ const BridgeProvider = ({
   pingInterval = CONFIG.PING_INTERVAL,
   maxRetryCooldown = CONFIG.MAX_RETRY_COOLDOWN,
   defaultTimeout = CONFIG.DEFAULT_TIMEOUT,
+  timeoutFailureThreshold = CONFIG.TIMEOUT_FAILURE_THRESHOLD_MS,
   onConnectionChange,
-  onError,
-  isHealthPausedUntil
+  onError
 }) => {
   const [bridge, setBridge] = useState(null);
   const [status, setStatus] = useState("connecting");
@@ -260,6 +277,7 @@ const BridgeProvider = ({
   const errorCheckIntervalRef = useRef(null);
   const consecutivePingFailuresRef = useRef(0);
   const consecutiveTimeoutsRef = useRef(0);
+  const healthPausedUntilRef = useRef(0);
   const reconnectionGracePeriodRef = useRef(false);
   const pendingRequestsRef = useRef(/* @__PURE__ */ new Map());
   const eventListenersRef = useRef(/* @__PURE__ */ new Map());
@@ -323,6 +341,9 @@ const BridgeProvider = ({
       reject(new Error("Bridge disconnected"));
     });
     pendingRequestsRef.current.clear();
+    if (!emitDisconnect) {
+      eventListenersRef.current.clear();
+    }
     setIsServiceWorkerAlive(false);
     setBridge(null);
     isConnectingRef.current = false;
@@ -351,6 +372,10 @@ const BridgeProvider = ({
           }
         }
       });
+      return;
+    }
+    if (message.id && BRIDGE_ENABLE_LOGS) {
+      console.warn("[Bridge] Received response for unknown/expired request:", message.id);
     }
   }, []);
   const scheduleReconnect = useCallback(
@@ -514,7 +539,9 @@ const BridgeProvider = ({
         isConnectedRef,
         consecutiveTimeoutsRef,
         reconnectionGracePeriodRef,
+        healthPausedUntilRef,
         defaultTimeout,
+        timeoutFailureThreshold,
         onReconnectNeeded: triggerReconnect
       });
       setBridge(bridgeInstance);
@@ -543,22 +570,24 @@ const BridgeProvider = ({
         }
       });
       const rejectAllPendingRequests = (message) => {
-        pendingRequestsRef.current.forEach(({ reject, timeout }) => {
-          clearTimeout(timeout);
-          reject(new Error(message));
+        pendingRequestsRef.current.forEach(({ reject, timeout, timeoutDuration }, id) => {
+          if (timeoutDuration <= timeoutFailureThreshold) {
+            clearTimeout(timeout);
+            reject(new Error(message));
+            pendingRequestsRef.current.delete(id);
+          }
         });
-        pendingRequestsRef.current.clear();
         consecutiveTimeoutsRef.current = 0;
       };
       startHealthMonitor({
         bridge: bridgeInstance,
         pingIntervalRef,
         consecutivePingFailuresRef,
+        healthPausedUntilRef,
         pingInterval,
         setIsServiceWorkerAlive,
         onReconnectNeeded: triggerReconnect,
-        rejectAllPendingRequests,
-        isHealthPausedUntil
+        rejectAllPendingRequests
       });
     } catch (e) {
       isConnectingRef.current = false;
@@ -574,8 +603,7 @@ const BridgeProvider = ({
     scheduleSwRestartReconnect,
     defaultTimeout,
     updateStatus,
-    pingInterval,
-    isHealthPausedUntil
+    pingInterval
   ]);
   const reconnect = useCallback(() => {
     retryCountRef.current = 0;
@@ -606,17 +634,21 @@ const BridgeProvider = ({
         isConnectingRef.current = false;
         connect();
       } else if (currentStatus === "connected" && currentBridge) {
+        if (isConnectingRef.current) return;
         currentBridge.ping().then((alive) => {
           if (!isMountedRef.current) return;
+          if (isConnectingRef.current) return;
           if (!alive) {
             {
               console.warn("[Bridge] Tab visible but unresponsive, reconnecting...");
             }
             retryCountRef.current = 0;
+            swRestartRetryCountRef.current = 0;
             isConnectingRef.current = false;
             cleanup();
             connect();
           }
+        }).catch(() => {
         });
       }
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chromahq/react",
-  "version": "1.0.35",
+  "version": "1.0.39",
   "description": "React bindings for the Chroma Chrome extension framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",