@schematichq/schematic-react 1.2.10 → 1.2.13

package/README.md

@@ -136,6 +136,43 @@ const MyComponent = () => {
 
 *Note: `useSchematicIsPending` is checking if entitlement data has been loaded, typically via `identify`. It should, therefore, be used to wrap flag and entitlement checks, but never the initial call to `identify`.*
 
+## React Native
+
+### Handling app background/foreground
+
+When a React Native app is backgrounded for an extended period, the WebSocket connection may be closed by the OS. When the app returns to the foreground, the connection will automatically reconnect, but this happens on an exponential backoff timer which may cause a delay before fresh flag values are available.
+
+For cases where you need immediate flag updates when returning to the foreground (e.g., after an in-app purchase), you can use one of these methods to re-establish the connection:
+
+- `forceReconnect()`: Always closes and re-establishes the WebSocket connection, guaranteeing fresh values
+- `reconnectIfNeeded()`: Only reconnects if the current connection is unhealthy (more efficient for frequent foreground events)
+
+```tsx
+import { useSchematic } from "@schematichq/schematic-react";
+import { useEffect } from "react";
+import { AppState } from "react-native";
+
+const SchematicAppStateHandler = () => {
+    const { client } = useSchematic();
+
+    useEffect(() => {
+        const subscription = AppState.addEventListener("change", (state) => {
+            if (state === "active") {
+                // Use forceReconnect() for guaranteed fresh values
+                client.forceReconnect();
+                // Or use reconnectIfNeeded() to skip if connection is healthy
+                // client.reconnectIfNeeded();
+            }
+        });
+        return () => subscription.remove();
+    }, [client]);
+
+    return null;
+};
+```
+
+Render this inside your `SchematicProvider`.
+
 ## Troubleshooting
 
 For debugging and development, Schematic supports two special modes:

package/dist/schematic-react.cjs.js

@@ -799,7 +799,7 @@ function contextString(context) {
   }, {});
   return JSON.stringify(sortedContext);
 }
-var version = "1.2.10";
+var version = "1.2.13";
 var anonymousIdKey = "schematicId";
 var Schematic = class {
   additionalHeaders = {};
@@ -824,6 +824,9 @@ var Schematic = class {
   webSocketConnectionTimeout = 1e4;
   webSocketReconnect = true;
   webSocketMaxReconnectAttempts = 7;
+  // Max attempts after connection disrupted
+  webSocketMaxConnectionAttempts = 3;
+  // Max attempts for initial connection
   webSocketInitialRetryDelay = 1e3;
   webSocketMaxRetryDelay = 3e4;
   wsReconnectAttempts = 0;
@@ -1047,7 +1050,7 @@ var Schematic = class {
         this.submitFlagCheckEvent(key, result, context);
         return result.value;
       }).catch((error) => {
-        console.error("There was a problem with the fetch operation:", error);
+        console.warn("There was a problem with the fetch operation:", error);
         const errorResult = this.resolveFallbackCheckFlagReturn(
           key,
           fallback,
@@ -1070,10 +1073,7 @@ var Schematic = class {
       try {
         await this.setContext(context);
       } catch (error) {
-        console.error(
-          "WebSocket connection failed, falling back to REST:",
-          error
-        );
+        console.warn("WebSocket connection failed, falling back to REST:", error);
         return this.fallbackToRest(key, context, fallback);
       }
       const contextVals = this.checks[contextStr] ?? {};
@@ -1213,7 +1213,7 @@ var Schematic = class {
       this.submitFlagCheckEvent(key, result, context);
       return result.value;
     } catch (error) {
-      console.error("REST API call failed, using fallback value:", error);
+      console.warn("REST API call failed, using fallback value:", error);
       const errorResult = this.resolveFallbackCheckFlagReturn(
         key,
         fallback,
@@ -1262,7 +1262,7 @@ var Schematic = class {
         {}
       );
     }).catch((error) => {
-      console.error("There was a problem with the fetch operation:", error);
+      console.warn("There was a problem with the fetch operation:", error);
       return {};
     });
   };
@@ -1279,7 +1279,7 @@ var Schematic = class {
         user: body.keys
       });
     } catch (error) {
-      console.error("Error setting context:", error);
+      console.warn("Error setting context:", error);
     }
     return this.handleEvent("identify", body);
   };
@@ -1337,7 +1337,7 @@ var Schematic = class {
       const socket = await this.conn;
       await this.wsSendMessage(socket, context);
     } catch (error) {
-      console.error("Failed to establish WebSocket connection:", error);
+      console.warn("Failed to establish WebSocket connection:", error);
       throw error;
     }
   };
@@ -1610,6 +1610,130 @@ var Schematic = class {
   /**
    * Websocket management
    */
+  /**
+   * Force an immediate WebSocket reconnection.
+   * This is useful when the application returns from a background state (e.g., mobile app
+   * coming back to foreground) and wants to immediately re-establish the connection
+   * rather than waiting for the exponential backoff timer.
+   *
+   * This method will:
+   * - Cancel any pending reconnection timer
+   * - Reset the reconnection attempt counter
+   * - Close any existing connection
+   * - Immediately attempt to reconnect
+   * - Re-send the current context to get fresh flag values
+   *
+   * Use this when you need guaranteed fresh values (e.g., after an in-app purchase).
+   *
+   * @example
+   * ```typescript
+   * // React Native example: reconnect when app comes to foreground
+   * useEffect(() => {
+   *   const subscription = AppState.addEventListener("change", (state) => {
+   *     if (state === "active") {
+   *       client.forceReconnect();
+   *     }
+   *   });
+   *   return () => subscription.remove();
+   * }, [client]);
+   * ```
+   */
+  forceReconnect = async () => {
+    return this.reconnect({ force: true });
+  };
+  /**
+   * Reconnect the WebSocket connection only if the current connection is unhealthy.
+   * This is useful when the application returns from a background state and wants to
+   * ensure a healthy connection exists, but doesn't need to force a reconnection if
+   * the connection is still active.
+   *
+   * This method will:
+   * - Check if an existing connection is healthy (readyState === OPEN)
+   * - If healthy, return immediately without reconnecting
+   * - If unhealthy, perform the same reconnection logic as forceReconnect()
+   *
+   * Use this when you want efficient reconnection that avoids unnecessary disconnects.
+   *
+   * @example
+   * ```typescript
+   * // React Native example: reconnect only if needed when app comes to foreground
+   * useEffect(() => {
+   *   const subscription = AppState.addEventListener("change", (state) => {
+   *     if (state === "active") {
+   *       client.reconnectIfNeeded();
+   *     }
+   *   });
+   *   return () => subscription.remove();
+   * }, [client]);
+   * ```
+   */
+  reconnectIfNeeded = async () => {
+    return this.reconnect({ force: false });
+  };
+  /**
+   * Internal method to handle reconnection logic for both forceReconnect and reconnectIfNeeded.
+   */
+  reconnect = async (options) => {
+    const { force } = options;
+    const methodName = force ? "forceReconnect" : "reconnectIfNeeded";
+    if (this.isOffline()) {
+      this.debug(`${methodName}: skipped (offline mode)`);
+      return Promise.resolve();
+    }
+    if (!force && this.conn !== null) {
+      try {
+        const existingSocket = await this.conn;
+        if (existingSocket.readyState === WebSocket.OPEN) {
+          this.debug(`${methodName}: connection is healthy, skipping`);
+          return Promise.resolve();
+        }
+      } catch {
+      }
+    }
+    this.debug(
+      `${methodName}: ${force ? "forcing immediate reconnection" : "reconnecting"}`
+    );
+    this.wsIntentionalDisconnect = false;
+    if (this.wsReconnectTimer !== null) {
+      this.debug(`${methodName}: cancelling pending reconnection timer`);
+      clearTimeout(this.wsReconnectTimer);
+      this.wsReconnectTimer = null;
+    }
+    this.wsReconnectAttempts = 0;
+    if (this.conn !== null) {
+      this.debug(`${methodName}: closing existing connection`);
+      try {
+        const existingSocket = await this.conn;
+        if (this.currentWebSocket === existingSocket) {
+          this.currentWebSocket = null;
+        }
+        if (existingSocket.readyState === WebSocket.OPEN || existingSocket.readyState === WebSocket.CONNECTING) {
+          existingSocket.close();
+        }
+      } catch (error) {
+        this.debug(`${methodName}: error closing existing connection:`, error);
+      }
+      this.conn = null;
+      this.isConnecting = false;
+    }
+    if (this.context.company !== void 0 || this.context.user !== void 0) {
+      this.debug(`${methodName}: reconnecting with existing context`);
+      try {
+        this.isConnecting = true;
+        this.conn = this.wsConnect();
+        const socket = await this.conn;
+        this.isConnecting = false;
+        await this.wsSendMessage(socket, this.context, true);
+        this.debug(`${methodName}: reconnection successful`);
+      } catch (error) {
+        this.isConnecting = false;
+        this.debug(`${methodName}: reconnection failed:`, error);
+      }
+    } else {
+      this.debug(`${methodName}: no context set, skipping reconnection`);
+    }
+    return Promise.resolve();
+  };
   /**
    * If using websocket mode, close the connection when done.
    * In offline mode, this is a no-op.
@@ -1634,7 +1758,7 @@ var Schematic = class {
         }
         socket.close();
       } catch (error) {
-        console.error("Error during cleanup:", error);
+        console.warn("Error during cleanup:", error);
       } finally {
         this.conn = null;
         this.currentWebSocket = null;
@@ -1777,14 +1901,49 @@ var Schematic = class {
       }
     }, delay);
   };
-  // Open a websocket connection
-  wsConnect = () => {
+  // Open a websocket connection with retry logic for timeouts
+  wsConnect = async () => {
     if (this.isOffline()) {
       this.debug("wsConnect: skipped (offline mode)");
-      return Promise.reject(
-        new Error("WebSocket connection skipped in offline mode")
-      );
+      throw new Error("WebSocket connection skipped in offline mode");
     }
+    let lastError = null;
+    const maxAttempts = this.webSocketMaxConnectionAttempts;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const socket = await this.wsConnectOnce();
+        this.wsReconnectAttempts = 0;
+        return socket;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const isTimeout = lastError.message === "WebSocket connection timeout";
+        if (!isTimeout) {
+          this.debug(
+            `WebSocket connection failed with non-timeout error, not retrying:`,
+            lastError.message
+          );
+          throw lastError;
+        }
+        if (attempt < maxAttempts - 1) {
+          const baseDelay = this.webSocketInitialRetryDelay * Math.pow(2, attempt);
+          const cappedDelay = Math.min(baseDelay, this.webSocketMaxRetryDelay);
+          const jitter = cappedDelay * 0.2 * Math.random();
+          const delay = cappedDelay + jitter;
+          this.debug(
+            `WebSocket connection timeout (attempt ${attempt + 1}/${maxAttempts}), retrying in ${delay.toFixed(0)}ms`
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          this.debug(
+            `WebSocket connection timeout (attempt ${attempt + 1}/${maxAttempts}), no more retries`
+          );
+        }
+      }
+    }
+    throw lastError ?? new Error("WebSocket connection failed");
+  };
+  // Single attempt to open a websocket connection (no retry logic)
+  wsConnectOnce = () => {
     return new Promise((resolve, reject) => {
       const wsUrl = `${this.webSocketUrl}/flags/bootstrap?apiKey=${this.apiKey}`;
       this.debug(`connecting to WebSocket:`, wsUrl);
@@ -1795,6 +1954,7 @@ var Schematic = class {
       let isResolved = false;
       timeoutId = setTimeout(() => {
         if (!isResolved) {
+          isResolved = true;
           this.debug(
             `WebSocket connection timeout after ${this.webSocketConnectionTimeout}ms`
           );
@@ -1803,16 +1963,17 @@ var Schematic = class {
         }
       }, this.webSocketConnectionTimeout);
       webSocket.onopen = () => {
+        if (isResolved) return;
         isResolved = true;
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
         }
-        this.wsReconnectAttempts = 0;
         this.wsIntentionalDisconnect = false;
         this.debug(`WebSocket connection ${connectionId} opened successfully`);
         resolve(webSocket);
       };
       webSocket.onerror = (error) => {
+        if (isResolved) return;
         isResolved = true;
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
@@ -1821,7 +1982,6 @@ var Schematic = class {
         reject(error);
       };
       webSocket.onclose = () => {
-        isResolved = true;
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
         }
@@ -1831,7 +1991,7 @@ var Schematic = class {
           this.currentWebSocket = null;
           this.isConnecting = false;
         }
-        if (!this.wsIntentionalDisconnect && this.webSocketReconnect) {
+        if (!isResolved && !this.wsIntentionalDisconnect && this.webSocketReconnect) {
           this.attemptReconnect();
         }
       };
@@ -2013,7 +2173,7 @@ var notifyFlagValueListener = (listener, value) => {
 var import_react = __toESM(require("react"));
 
 // src/version.ts
-var version2 = "1.2.10";
+var version2 = "1.2.13";
 
 // src/context/schematic.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
@@ -2028,7 +2188,7 @@ var SchematicProvider = ({
 }) => {
   const initialOptsRef = (0, import_react.useRef)({
     publishableKey,
-    useWebSocket: clientOpts.useWebSocket ?? true,
+    useWebSocket: true,
     additionalHeaders: {
       "X-Schematic-Client-Version": `schematic-react@${version2}`
     },

package/dist/schematic-react.d.ts

@@ -15,7 +15,7 @@ import { StoragePersister } from '@schematichq/schematic-js';
 import { Traits } from '@schematichq/schematic-js';
 import { UsagePeriod } from '@schematichq/schematic-js';
 
-declare type BaseSchematicProviderProps = Omit<SchematicJS.SchematicOptions, "client" | "publishableKey"> & {
+declare type BaseSchematicProviderProps = Omit<SchematicJS.SchematicOptions, "client" | "publishableKey" | "useWebSocket"> & {
     children: React_2.ReactNode;
 };
 

package/dist/schematic-react.esm.js

@@ -754,7 +754,7 @@ function contextString(context) {
   }, {});
   return JSON.stringify(sortedContext);
 }
-var version = "1.2.10";
+var version = "1.2.13";
 var anonymousIdKey = "schematicId";
 var Schematic = class {
   additionalHeaders = {};
@@ -779,6 +779,9 @@ var Schematic = class {
   webSocketConnectionTimeout = 1e4;
   webSocketReconnect = true;
   webSocketMaxReconnectAttempts = 7;
+  // Max attempts after connection disrupted
+  webSocketMaxConnectionAttempts = 3;
+  // Max attempts for initial connection
   webSocketInitialRetryDelay = 1e3;
   webSocketMaxRetryDelay = 3e4;
   wsReconnectAttempts = 0;
@@ -1002,7 +1005,7 @@ var Schematic = class {
         this.submitFlagCheckEvent(key, result, context);
         return result.value;
       }).catch((error) => {
-        console.error("There was a problem with the fetch operation:", error);
+        console.warn("There was a problem with the fetch operation:", error);
         const errorResult = this.resolveFallbackCheckFlagReturn(
           key,
           fallback,
@@ -1025,10 +1028,7 @@ var Schematic = class {
       try {
         await this.setContext(context);
       } catch (error) {
-        console.error(
-          "WebSocket connection failed, falling back to REST:",
-          error
-        );
+        console.warn("WebSocket connection failed, falling back to REST:", error);
         return this.fallbackToRest(key, context, fallback);
       }
       const contextVals = this.checks[contextStr] ?? {};
@@ -1168,7 +1168,7 @@ var Schematic = class {
       this.submitFlagCheckEvent(key, result, context);
       return result.value;
     } catch (error) {
-      console.error("REST API call failed, using fallback value:", error);
+      console.warn("REST API call failed, using fallback value:", error);
       const errorResult = this.resolveFallbackCheckFlagReturn(
         key,
         fallback,
@@ -1217,7 +1217,7 @@ var Schematic = class {
         {}
       );
     }).catch((error) => {
-      console.error("There was a problem with the fetch operation:", error);
+      console.warn("There was a problem with the fetch operation:", error);
       return {};
     });
   };
@@ -1234,7 +1234,7 @@ var Schematic = class {
         user: body.keys
       });
     } catch (error) {
-      console.error("Error setting context:", error);
+      console.warn("Error setting context:", error);
     }
     return this.handleEvent("identify", body);
   };
@@ -1292,7 +1292,7 @@ var Schematic = class {
       const socket = await this.conn;
       await this.wsSendMessage(socket, context);
     } catch (error) {
-      console.error("Failed to establish WebSocket connection:", error);
+      console.warn("Failed to establish WebSocket connection:", error);
       throw error;
     }
   };
@@ -1565,6 +1565,130 @@ var Schematic = class {
   /**
    * Websocket management
    */
+  /**
+   * Force an immediate WebSocket reconnection.
+   * This is useful when the application returns from a background state (e.g., mobile app
+   * coming back to foreground) and wants to immediately re-establish the connection
+   * rather than waiting for the exponential backoff timer.
+   *
+   * This method will:
+   * - Cancel any pending reconnection timer
+   * - Reset the reconnection attempt counter
+   * - Close any existing connection
+   * - Immediately attempt to reconnect
+   * - Re-send the current context to get fresh flag values
+   *
+   * Use this when you need guaranteed fresh values (e.g., after an in-app purchase).
+   *
+   * @example
+   * ```typescript
+   * // React Native example: reconnect when app comes to foreground
+   * useEffect(() => {
+   *   const subscription = AppState.addEventListener("change", (state) => {
+   *     if (state === "active") {
+   *       client.forceReconnect();
+   *     }
+   *   });
+   *   return () => subscription.remove();
+   * }, [client]);
+   * ```
+   */
+  forceReconnect = async () => {
+    return this.reconnect({ force: true });
+  };
+  /**
+   * Reconnect the WebSocket connection only if the current connection is unhealthy.
+   * This is useful when the application returns from a background state and wants to
+   * ensure a healthy connection exists, but doesn't need to force a reconnection if
+   * the connection is still active.
+   *
+   * This method will:
+   * - Check if an existing connection is healthy (readyState === OPEN)
+   * - If healthy, return immediately without reconnecting
+   * - If unhealthy, perform the same reconnection logic as forceReconnect()
+   *
+   * Use this when you want efficient reconnection that avoids unnecessary disconnects.
+   *
+   * @example
+   * ```typescript
+   * // React Native example: reconnect only if needed when app comes to foreground
+   * useEffect(() => {
+   *   const subscription = AppState.addEventListener("change", (state) => {
+   *     if (state === "active") {
+   *       client.reconnectIfNeeded();
+   *     }
+   *   });
+   *   return () => subscription.remove();
+   * }, [client]);
+   * ```
+   */
+  reconnectIfNeeded = async () => {
+    return this.reconnect({ force: false });
+  };
+  /**
+   * Internal method to handle reconnection logic for both forceReconnect and reconnectIfNeeded.
+   */
+  reconnect = async (options) => {
+    const { force } = options;
+    const methodName = force ? "forceReconnect" : "reconnectIfNeeded";
+    if (this.isOffline()) {
+      this.debug(`${methodName}: skipped (offline mode)`);
+      return Promise.resolve();
+    }
+    if (!force && this.conn !== null) {
+      try {
+        const existingSocket = await this.conn;
+        if (existingSocket.readyState === WebSocket.OPEN) {
+          this.debug(`${methodName}: connection is healthy, skipping`);
+          return Promise.resolve();
+        }
+      } catch {
+      }
+    }
+    this.debug(
+      `${methodName}: ${force ? "forcing immediate reconnection" : "reconnecting"}`
+    );
+    this.wsIntentionalDisconnect = false;
+    if (this.wsReconnectTimer !== null) {
+      this.debug(`${methodName}: cancelling pending reconnection timer`);
+      clearTimeout(this.wsReconnectTimer);
+      this.wsReconnectTimer = null;
+    }
+    this.wsReconnectAttempts = 0;
+    if (this.conn !== null) {
+      this.debug(`${methodName}: closing existing connection`);
+      try {
+        const existingSocket = await this.conn;
+        if (this.currentWebSocket === existingSocket) {
+          this.currentWebSocket = null;
+        }
+        if (existingSocket.readyState === WebSocket.OPEN || existingSocket.readyState === WebSocket.CONNECTING) {
+          existingSocket.close();
+        }
+      } catch (error) {
+        this.debug(`${methodName}: error closing existing connection:`, error);
+      }
+      this.conn = null;
+      this.isConnecting = false;
+    }
+    if (this.context.company !== void 0 || this.context.user !== void 0) {
+      this.debug(`${methodName}: reconnecting with existing context`);
+      try {
+        this.isConnecting = true;
+        this.conn = this.wsConnect();
+        const socket = await this.conn;
+        this.isConnecting = false;
+        await this.wsSendMessage(socket, this.context, true);
+        this.debug(`${methodName}: reconnection successful`);
+      } catch (error) {
+        this.isConnecting = false;
+        this.debug(`${methodName}: reconnection failed:`, error);
+      }
+    } else {
+      this.debug(`${methodName}: no context set, skipping reconnection`);
+    }
+    return Promise.resolve();
+  };
   /**
    * If using websocket mode, close the connection when done.
    * In offline mode, this is a no-op.
@@ -1589,7 +1713,7 @@ var Schematic = class {
         }
         socket.close();
       } catch (error) {
-        console.error("Error during cleanup:", error);
+        console.warn("Error during cleanup:", error);
       } finally {
         this.conn = null;
         this.currentWebSocket = null;
@@ -1732,14 +1856,49 @@ var Schematic = class {
       }
     }, delay);
   };
-  // Open a websocket connection
-  wsConnect = () => {
+  // Open a websocket connection with retry logic for timeouts
+  wsConnect = async () => {
     if (this.isOffline()) {
       this.debug("wsConnect: skipped (offline mode)");
-      return Promise.reject(
-        new Error("WebSocket connection skipped in offline mode")
-      );
+      throw new Error("WebSocket connection skipped in offline mode");
     }
+    let lastError = null;
+    const maxAttempts = this.webSocketMaxConnectionAttempts;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const socket = await this.wsConnectOnce();
+        this.wsReconnectAttempts = 0;
+        return socket;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        const isTimeout = lastError.message === "WebSocket connection timeout";
+        if (!isTimeout) {
+          this.debug(
+            `WebSocket connection failed with non-timeout error, not retrying:`,
+            lastError.message
+          );
+          throw lastError;
+        }
+        if (attempt < maxAttempts - 1) {
+          const baseDelay = this.webSocketInitialRetryDelay * Math.pow(2, attempt);
+          const cappedDelay = Math.min(baseDelay, this.webSocketMaxRetryDelay);
+          const jitter = cappedDelay * 0.2 * Math.random();
+          const delay = cappedDelay + jitter;
+          this.debug(
+            `WebSocket connection timeout (attempt ${attempt + 1}/${maxAttempts}), retrying in ${delay.toFixed(0)}ms`
+          );
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          this.debug(
+            `WebSocket connection timeout (attempt ${attempt + 1}/${maxAttempts}), no more retries`
+          );
+        }
+      }
+    }
+    throw lastError ?? new Error("WebSocket connection failed");
+  };
+  // Single attempt to open a websocket connection (no retry logic)
+  wsConnectOnce = () => {
     return new Promise((resolve, reject) => {
       const wsUrl = `${this.webSocketUrl}/flags/bootstrap?apiKey=${this.apiKey}`;
       this.debug(`connecting to WebSocket:`, wsUrl);
@@ -1750,6 +1909,7 @@ var Schematic = class {
       let isResolved = false;
       timeoutId = setTimeout(() => {
         if (!isResolved) {
+          isResolved = true;
           this.debug(
             `WebSocket connection timeout after ${this.webSocketConnectionTimeout}ms`
           );
@@ -1758,16 +1918,17 @@ var Schematic = class {
         }
       }, this.webSocketConnectionTimeout);
       webSocket.onopen = () => {
+        if (isResolved) return;
         isResolved = true;
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
         }
-        this.wsReconnectAttempts = 0;
         this.wsIntentionalDisconnect = false;
         this.debug(`WebSocket connection ${connectionId} opened successfully`);
         resolve(webSocket);
       };
       webSocket.onerror = (error) => {
+        if (isResolved) return;
         isResolved = true;
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
@@ -1776,7 +1937,6 @@ var Schematic = class {
         reject(error);
       };
       webSocket.onclose = () => {
-        isResolved = true;
         if (timeoutId !== null) {
           clearTimeout(timeoutId);
         }
@@ -1786,7 +1946,7 @@ var Schematic = class {
           this.currentWebSocket = null;
           this.isConnecting = false;
         }
-        if (!this.wsIntentionalDisconnect && this.webSocketReconnect) {
+        if (!isResolved && !this.wsIntentionalDisconnect && this.webSocketReconnect) {
           this.attemptReconnect();
         }
       };
@@ -1968,7 +2128,7 @@ var notifyFlagValueListener = (listener, value) => {
 import React, { createContext, useEffect, useMemo, useRef } from "react";
 
 // src/version.ts
-var version2 = "1.2.10";
+var version2 = "1.2.13";
 
 // src/context/schematic.tsx
 import { jsx } from "react/jsx-runtime";
@@ -1983,7 +2143,7 @@ var SchematicProvider = ({
 }) => {
   const initialOptsRef = useRef({
     publishableKey,
-    useWebSocket: clientOpts.useWebSocket ?? true,
+    useWebSocket: true,
     additionalHeaders: {
       "X-Schematic-Client-Version": `schematic-react@${version2}`
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schematichq/schematic-react",
-  "version": "1.2.10",
+  "version": "1.2.13",
   "main": "dist/schematic-react.cjs.js",
   "module": "dist/schematic-react.esm.js",
   "types": "dist/schematic-react.d.ts",
@@ -31,7 +31,7 @@
     "prepare": "husky"
   },
   "dependencies": {
-    "@schematichq/schematic-js": "^1.2.10"
+    "@schematichq/schematic-js": "^1.2.13"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",