@schematichq/schematic-react 1.2.7 → 1.2.9

package/dist/schematic-react.cjs.js

@@ -799,7 +799,7 @@ function contextString(context) {
   }, {});
   return JSON.stringify(sortedContext);
 }
-var version = "1.2.7";
+var version = "1.2.9";
 var anonymousIdKey = "schematicId";
 var Schematic = class {
   additionalHeaders = {};
@@ -829,6 +829,17 @@ var Schematic = class {
   wsReconnectAttempts = 0;
   wsReconnectTimer = null;
   wsIntentionalDisconnect = false;
+  maxEventQueueSize = 100;
+  // Prevent memory issues with very long network outages
+  maxEventRetries = 5;
+  // Maximum retry attempts for failed events
+  eventRetryInitialDelay = 1e3;
+  // Initial retry delay in ms
+  eventRetryMaxDelay = 3e4;
+  // Maximum retry delay in ms
+  retryTimer = null;
+  flagValueDefaults = {};
+  flagCheckDefaults = {};
   constructor(apiKey, options) {
     this.apiKey = apiKey;
     this.eventQueue = [];
@@ -887,6 +898,24 @@ var Schematic = class {
     if (options?.webSocketMaxRetryDelay !== void 0) {
       this.webSocketMaxRetryDelay = options.webSocketMaxRetryDelay;
     }
+    if (options?.maxEventQueueSize !== void 0) {
+      this.maxEventQueueSize = options.maxEventQueueSize;
+    }
+    if (options?.maxEventRetries !== void 0) {
+      this.maxEventRetries = options.maxEventRetries;
+    }
+    if (options?.eventRetryInitialDelay !== void 0) {
+      this.eventRetryInitialDelay = options.eventRetryInitialDelay;
+    }
+    if (options?.eventRetryMaxDelay !== void 0) {
+      this.eventRetryMaxDelay = options.eventRetryMaxDelay;
+    }
+    if (options?.flagValueDefaults !== void 0) {
+      this.flagValueDefaults = options.flagValueDefaults;
+    }
+    if (options?.flagCheckDefaults !== void 0) {
+      this.flagCheckDefaults = options.flagCheckDefaults;
+    }
     if (typeof window !== "undefined" && window?.addEventListener) {
       window.addEventListener("beforeunload", () => {
         this.flushEventQueue();
@@ -911,6 +940,62 @@ var Schematic = class {
       this.debug("Initialized with debug mode enabled");
     }
   }
+  /**
+   * Resolve fallback value according to priority order:
+   * 1. Callsite fallback value (if provided)
+   * 2. Initialization fallback value (flagValueDefaults)
+   * 3. Default to false
+   */
+  resolveFallbackValue(key, callsiteFallback) {
+    if (callsiteFallback !== void 0) {
+      return callsiteFallback;
+    }
+    if (key in this.flagValueDefaults) {
+      return this.flagValueDefaults[key];
+    }
+    return false;
+  }
+  /**
+   * Resolve complete CheckFlagReturn object according to priority order:
+   * 1. Use callsite fallback for boolean value, construct CheckFlagReturn
+   * 2. Use flagCheckDefaults if available for this flag
+   * 3. Use flagValueDefaults if available for this flag, construct CheckFlagReturn
+   * 4. Default CheckFlagReturn with value: false
+   */
+  resolveFallbackCheckFlagReturn(key, callsiteFallback, reason = "Fallback value used", error) {
+    if (callsiteFallback !== void 0) {
+      return {
+        flag: key,
+        value: callsiteFallback,
+        reason,
+        error
+      };
+    }
+    if (key in this.flagCheckDefaults) {
+      const defaultReturn = this.flagCheckDefaults[key];
+      return {
+        ...defaultReturn,
+        flag: key,
+        // Ensure flag matches the requested key
+        reason: error !== void 0 ? reason : defaultReturn.reason,
+        error
+      };
+    }
+    if (key in this.flagValueDefaults) {
+      return {
+        flag: key,
+        value: this.flagValueDefaults[key],
+        reason,
+        error
+      };
+    }
+    return {
+      flag: key,
+      value: false,
+      reason,
+      error
+    };
+  }
   /**
    * Get value for a single flag.
    * In WebSocket mode, returns cached values if connection is active, otherwise establishes
@@ -919,16 +1004,21 @@ var Schematic = class {
    * In REST mode, makes an API call for each check.
    */
   async checkFlag(options) {
-    const { fallback = false, key } = options;
+    const { fallback, key } = options;
     const context = options.context || this.context;
     const contextStr = contextString(context);
     this.debug(`checkFlag: ${key}`, { context, fallback });
     if (this.isOffline()) {
+      const resolvedFallbackResult = this.resolveFallbackCheckFlagReturn(
+        key,
+        fallback,
+        "Offline mode - using initialization defaults"
+      );
       this.debug(`checkFlag offline result: ${key}`, {
-        value: fallback,
+        value: resolvedFallbackResult.value,
         offlineMode: true
       });
-      return fallback;
+      return resolvedFallbackResult.value;
     }
     if (!this.useWebSocket) {
       const requestUrl = `${this.apiUrl}/flags/${key}/check`;
@@ -956,14 +1046,14 @@ var Schematic = class {
         return result.value;
       }).catch((error) => {
         console.error("There was a problem with the fetch operation:", error);
-        const errorResult = {
-          flag: key,
-          value: fallback,
-          reason: "API request failed",
-          error: error instanceof Error ? error.message : String(error)
-        };
+        const errorResult = this.resolveFallbackCheckFlagReturn(
+          key,
+          fallback,
+          "API request failed",
+          error instanceof Error ? error.message : String(error)
+        );
         this.submitFlagCheckEvent(key, errorResult, context);
-        return fallback;
+        return errorResult.value;
       });
     }
     try {
@@ -973,7 +1063,7 @@ var Schematic = class {
         return existingVals[key].value;
       }
       if (this.isOffline()) {
-        return fallback;
+        return this.resolveFallbackValue(key, fallback);
       }
       try {
         await this.setContext(context);
@@ -986,10 +1076,10 @@ var Schematic = class {
       }
       const contextVals = this.checks[contextStr] ?? {};
       const flagCheck = contextVals[key];
-      const result = flagCheck?.value ?? fallback;
+      const result = flagCheck?.value ?? this.resolveFallbackValue(key, fallback);
       this.debug(
         `checkFlag WebSocket result: ${key}`,
-        typeof flagCheck !== "undefined" ? flagCheck : { value: fallback, fallbackUsed: true }
+        typeof flagCheck !== "undefined" ? flagCheck : { value: result, fallbackUsed: true }
       );
       if (typeof flagCheck !== "undefined") {
         this.submitFlagCheckEvent(key, flagCheck, context);
@@ -997,14 +1087,14 @@ var Schematic = class {
       return result;
     } catch (error) {
       console.error("Unexpected error in checkFlag:", error);
-      const errorResult = {
-        flag: key,
-        value: fallback,
-        reason: "Unexpected error in flag check",
-        error: error instanceof Error ? error.message : String(error)
-      };
+      const errorResult = this.resolveFallbackCheckFlagReturn(
+        key,
+        fallback,
+        "Unexpected error in flag check",
+        error instanceof Error ? error.message : String(error)
+      );
       this.submitFlagCheckEvent(key, errorResult, context);
-      return fallback;
+      return errorResult.value;
     }
   }
   /**
@@ -1047,11 +1137,12 @@ var Schematic = class {
    */
   async fallbackToRest(key, context, fallback) {
     if (this.isOffline()) {
+      const resolvedFallback = this.resolveFallbackValue(key, fallback);
       this.debug(`fallbackToRest offline result: ${key}`, {
-        value: fallback,
+        value: resolvedFallback,
         offlineMode: true
       });
-      return fallback;
+      return resolvedFallback;
     }
     try {
       const requestUrl = `${this.apiUrl}/flags/${key}/check`;
@@ -1078,14 +1169,14 @@ var Schematic = class {
       return result.value;
     } catch (error) {
       console.error("REST API call failed, using fallback value:", error);
-      const errorResult = {
-        flag: key,
-        value: fallback,
-        reason: "API request failed (fallback)",
-        error: error instanceof Error ? error.message : String(error)
-      };
+      const errorResult = this.resolveFallbackCheckFlagReturn(
+        key,
+        fallback,
+        "API request failed (fallback)",
+        error instanceof Error ? error.message : String(error)
+      );
       this.submitFlagCheckEvent(key, errorResult, context);
-      return fallback;
+      return errorResult.value;
     }
   }
   /**
@@ -1302,11 +1393,53 @@ var Schematic = class {
       }
     }
   };
-  flushEventQueue = () => {
-    while (this.eventQueue.length > 0) {
-      const event = this.eventQueue.shift();
-      if (event) {
-        this.sendEvent(event);
+  startRetryTimer = () => {
+    if (this.retryTimer !== null) {
+      return;
+    }
+    this.retryTimer = setInterval(() => {
+      this.flushEventQueue().catch((error) => {
+        this.debug("Error in retry timer flush:", error);
+      });
+      if (this.eventQueue.length === 0) {
+        this.stopRetryTimer();
+      }
+    }, 5e3);
+    this.debug("Started retry timer");
+  };
+  stopRetryTimer = () => {
+    if (this.retryTimer !== null) {
+      clearInterval(this.retryTimer);
+      this.retryTimer = null;
+      this.debug("Stopped retry timer");
+    }
+  };
+  flushEventQueue = async () => {
+    if (this.eventQueue.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    const readyEvents = [];
+    const notReadyEvents = [];
+    for (const event of this.eventQueue) {
+      if (event.next_retry_at === void 0 || event.next_retry_at <= now) {
+        readyEvents.push(event);
+      } else {
+        notReadyEvents.push(event);
+      }
+    }
+    if (readyEvents.length === 0) {
+      this.debug(`No events ready for retry yet (${notReadyEvents.length} still in backoff)`);
+      return;
+    }
+    this.debug(`Flushing event queue: ${readyEvents.length} ready, ${notReadyEvents.length} waiting`);
+    this.eventQueue = notReadyEvents;
+    for (const event of readyEvents) {
+      try {
+        await this.sendEvent(event);
+        this.debug(`Queued event sent successfully:`, event.type);
+      } catch (error) {
+        this.debug(`Failed to send queued event:`, error);
       }
     }
   };
@@ -1354,12 +1487,37 @@ var Schematic = class {
         },
         body: payload
       });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
       this.debug(`event sent:`, {
         status: response.status,
         statusText: response.statusText
       });
     } catch (error) {
-      console.error("Error sending Schematic event: ", error);
+      const retryCount = (event.retry_count ?? 0) + 1;
+      if (retryCount <= this.maxEventRetries) {
+        this.debug(`Event failed to send (attempt ${retryCount}/${this.maxEventRetries}), queueing for retry:`, error);
+        const baseDelay = this.eventRetryInitialDelay * Math.pow(2, retryCount - 1);
+        const jitterDelay = Math.min(baseDelay, this.eventRetryMaxDelay);
+        const nextRetryAt = Date.now() + jitterDelay;
+        const retryEvent = {
+          ...event,
+          retry_count: retryCount,
+          next_retry_at: nextRetryAt
+        };
+        if (this.eventQueue.length < this.maxEventQueueSize) {
+          this.eventQueue.push(retryEvent);
+          this.debug(`Event queued for retry in ${jitterDelay}ms (${this.eventQueue.length}/${this.maxEventQueueSize})`);
+        } else {
+          this.debug(`Event queue full (${this.maxEventQueueSize}), dropping oldest event`);
+          this.eventQueue.shift();
+          this.eventQueue.push(retryEvent);
+        }
+        this.startRetryTimer();
+      } else {
+        this.debug(`Event failed permanently after ${this.maxEventRetries} attempts, dropping:`, error);
+      }
     }
     return Promise.resolve();
   };
@@ -1384,6 +1542,7 @@ var Schematic = class {
       clearTimeout(this.wsReconnectTimer);
       this.wsReconnectTimer = null;
     }
+    this.stopRetryTimer();
     if (this.conn) {
       try {
         const socket = await this.conn;
@@ -1431,16 +1590,15 @@ var Schematic = class {
    * Handle browser coming back online
    */
   handleNetworkOnline = () => {
-    if (this.context.company === void 0 && this.context.user === void 0) {
-      this.debug("No context set, skipping reconnection");
-      return;
-    }
+    this.debug("Network online, attempting reconnection and flushing queued events");
     this.wsReconnectAttempts = 0;
     if (this.wsReconnectTimer !== null) {
       clearTimeout(this.wsReconnectTimer);
       this.wsReconnectTimer = null;
     }
-    this.debug("Network online, reconnecting immediately");
+    this.flushEventQueue().catch((error) => {
+      this.debug("Error flushing event queue on network online:", error);
+    });
     this.attemptReconnect();
   };
   /**
@@ -1470,10 +1628,20 @@ var Schematic = class {
       try {
         this.conn = this.wsConnect();
         const socket = await this.conn;
+        this.debug(`Reconnection context check:`, {
+          hasCompany: this.context.company !== void 0,
+          hasUser: this.context.user !== void 0,
+          context: this.context
+        });
         if (this.context.company !== void 0 || this.context.user !== void 0) {
-          this.debug(`Reconnected, re-sending context`);
-          await this.wsSendMessage(socket, this.context);
+          this.debug(`Reconnected, force re-sending context`);
+          await this.wsSendContextAfterReconnection(socket, this.context);
+        } else {
+          this.debug(`No context to re-send after reconnection - websocket ready for new context`);
         }
+        this.flushEventQueue().catch((error) => {
+          this.debug("Error flushing event queue after websocket reconnection:", error);
+        });
         this.debug(`Reconnection successful`);
       } catch (error) {
         this.debug(`Reconnection attempt failed:`, error);
@@ -1534,6 +1702,61 @@ var Schematic = class {
       };
     });
   };
+  // Send a message on the websocket after reconnection, forcing the send even if context appears unchanged
+  // because the server has lost all state and needs the initial context
+  wsSendContextAfterReconnection = (socket, context) => {
+    if (this.isOffline()) {
+      this.debug("wsSendContextAfterReconnection: skipped (offline mode)");
+      this.setIsPending(false);
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.debug(`WebSocket force sending context after reconnection:`, context);
+      this.context = context;
+      const sendMessage = () => {
+        let resolved = false;
+        const messageHandler = (event) => {
+          const message = JSON.parse(event.data);
+          this.debug(`WebSocket message received after reconnection:`, message);
+          if (!(contextString(context) in this.checks)) {
+            this.checks[contextString(context)] = {};
+          }
+          (message.flags ?? []).forEach((flag) => {
+            const flagCheck = CheckFlagReturnFromJSON(flag);
+            const contextStr = contextString(context);
+            if (this.checks[contextStr] === void 0) {
+              this.checks[contextStr] = {};
+            }
+            this.checks[contextStr][flagCheck.flag] = flagCheck;
+          });
+          this.useWebSocket = true;
+          socket.removeEventListener("message", messageHandler);
+          if (!resolved) {
+            resolved = true;
+            resolve(this.setIsPending(false));
+          }
+        };
+        socket.addEventListener("message", messageHandler);
+        const clientVersion = this.additionalHeaders["X-Schematic-Client-Version"] ?? `schematic-js@${version}`;
+        const messagePayload = {
+          apiKey: this.apiKey,
+          clientVersion,
+          data: context
+        };
+        this.debug(`WebSocket sending forced message after reconnection:`, messagePayload);
+        socket.send(JSON.stringify(messagePayload));
+      };
+      if (socket.readyState === WebSocket.OPEN) {
+        this.debug(`WebSocket already open, sending forced message after reconnection`);
+        sendMessage();
+      } else {
+        socket.addEventListener("open", () => {
+          this.debug(`WebSocket opened, sending forced message after reconnection`);
+          sendMessage();
+        });
+      }
+    });
+  };
   // Send a message on the websocket indicating interest in a particular evaluation context
   // and wait for the initial set of flag values to be returned
   wsSendMessage = (socket, context) => {
@@ -1722,7 +1945,7 @@ var notifyFlagValueListener = (listener, value) => {
 var import_react = __toESM(require("react"));
 
 // src/version.ts
-var version2 = "1.2.7";
+var version2 = "1.2.9";
 
 // src/context/schematic.tsx
 var import_jsx_runtime = require("react/jsx-runtime");

package/dist/schematic-react.esm.js

@@ -754,7 +754,7 @@ function contextString(context) {
   }, {});
   return JSON.stringify(sortedContext);
 }
-var version = "1.2.7";
+var version = "1.2.9";
 var anonymousIdKey = "schematicId";
 var Schematic = class {
   additionalHeaders = {};
@@ -784,6 +784,17 @@ var Schematic = class {
   wsReconnectAttempts = 0;
   wsReconnectTimer = null;
   wsIntentionalDisconnect = false;
+  maxEventQueueSize = 100;
+  // Prevent memory issues with very long network outages
+  maxEventRetries = 5;
+  // Maximum retry attempts for failed events
+  eventRetryInitialDelay = 1e3;
+  // Initial retry delay in ms
+  eventRetryMaxDelay = 3e4;
+  // Maximum retry delay in ms
+  retryTimer = null;
+  flagValueDefaults = {};
+  flagCheckDefaults = {};
   constructor(apiKey, options) {
     this.apiKey = apiKey;
     this.eventQueue = [];
@@ -842,6 +853,24 @@ var Schematic = class {
     if (options?.webSocketMaxRetryDelay !== void 0) {
       this.webSocketMaxRetryDelay = options.webSocketMaxRetryDelay;
     }
+    if (options?.maxEventQueueSize !== void 0) {
+      this.maxEventQueueSize = options.maxEventQueueSize;
+    }
+    if (options?.maxEventRetries !== void 0) {
+      this.maxEventRetries = options.maxEventRetries;
+    }
+    if (options?.eventRetryInitialDelay !== void 0) {
+      this.eventRetryInitialDelay = options.eventRetryInitialDelay;
+    }
+    if (options?.eventRetryMaxDelay !== void 0) {
+      this.eventRetryMaxDelay = options.eventRetryMaxDelay;
+    }
+    if (options?.flagValueDefaults !== void 0) {
+      this.flagValueDefaults = options.flagValueDefaults;
+    }
+    if (options?.flagCheckDefaults !== void 0) {
+      this.flagCheckDefaults = options.flagCheckDefaults;
+    }
     if (typeof window !== "undefined" && window?.addEventListener) {
       window.addEventListener("beforeunload", () => {
         this.flushEventQueue();
@@ -866,6 +895,62 @@ var Schematic = class {
       this.debug("Initialized with debug mode enabled");
     }
   }
+  /**
+   * Resolve fallback value according to priority order:
+   * 1. Callsite fallback value (if provided)
+   * 2. Initialization fallback value (flagValueDefaults)
+   * 3. Default to false
+   */
+  resolveFallbackValue(key, callsiteFallback) {
+    if (callsiteFallback !== void 0) {
+      return callsiteFallback;
+    }
+    if (key in this.flagValueDefaults) {
+      return this.flagValueDefaults[key];
+    }
+    return false;
+  }
+  /**
+   * Resolve complete CheckFlagReturn object according to priority order:
+   * 1. Use callsite fallback for boolean value, construct CheckFlagReturn
+   * 2. Use flagCheckDefaults if available for this flag
+   * 3. Use flagValueDefaults if available for this flag, construct CheckFlagReturn
+   * 4. Default CheckFlagReturn with value: false
+   */
+  resolveFallbackCheckFlagReturn(key, callsiteFallback, reason = "Fallback value used", error) {
+    if (callsiteFallback !== void 0) {
+      return {
+        flag: key,
+        value: callsiteFallback,
+        reason,
+        error
+      };
+    }
+    if (key in this.flagCheckDefaults) {
+      const defaultReturn = this.flagCheckDefaults[key];
+      return {
+        ...defaultReturn,
+        flag: key,
+        // Ensure flag matches the requested key
+        reason: error !== void 0 ? reason : defaultReturn.reason,
+        error
+      };
+    }
+    if (key in this.flagValueDefaults) {
+      return {
+        flag: key,
+        value: this.flagValueDefaults[key],
+        reason,
+        error
+      };
+    }
+    return {
+      flag: key,
+      value: false,
+      reason,
+      error
+    };
+  }
   /**
    * Get value for a single flag.
    * In WebSocket mode, returns cached values if connection is active, otherwise establishes
@@ -874,16 +959,21 @@ var Schematic = class {
    * In REST mode, makes an API call for each check.
    */
   async checkFlag(options) {
-    const { fallback = false, key } = options;
+    const { fallback, key } = options;
     const context = options.context || this.context;
     const contextStr = contextString(context);
     this.debug(`checkFlag: ${key}`, { context, fallback });
     if (this.isOffline()) {
+      const resolvedFallbackResult = this.resolveFallbackCheckFlagReturn(
+        key,
+        fallback,
+        "Offline mode - using initialization defaults"
+      );
       this.debug(`checkFlag offline result: ${key}`, {
-        value: fallback,
+        value: resolvedFallbackResult.value,
         offlineMode: true
       });
-      return fallback;
+      return resolvedFallbackResult.value;
     }
     if (!this.useWebSocket) {
       const requestUrl = `${this.apiUrl}/flags/${key}/check`;
@@ -911,14 +1001,14 @@ var Schematic = class {
         return result.value;
       }).catch((error) => {
         console.error("There was a problem with the fetch operation:", error);
-        const errorResult = {
-          flag: key,
-          value: fallback,
-          reason: "API request failed",
-          error: error instanceof Error ? error.message : String(error)
-        };
+        const errorResult = this.resolveFallbackCheckFlagReturn(
+          key,
+          fallback,
+          "API request failed",
+          error instanceof Error ? error.message : String(error)
+        );
         this.submitFlagCheckEvent(key, errorResult, context);
-        return fallback;
+        return errorResult.value;
       });
     }
     try {
@@ -928,7 +1018,7 @@ var Schematic = class {
         return existingVals[key].value;
       }
       if (this.isOffline()) {
-        return fallback;
+        return this.resolveFallbackValue(key, fallback);
       }
       try {
         await this.setContext(context);
@@ -941,10 +1031,10 @@ var Schematic = class {
       }
       const contextVals = this.checks[contextStr] ?? {};
       const flagCheck = contextVals[key];
-      const result = flagCheck?.value ?? fallback;
+      const result = flagCheck?.value ?? this.resolveFallbackValue(key, fallback);
       this.debug(
         `checkFlag WebSocket result: ${key}`,
-        typeof flagCheck !== "undefined" ? flagCheck : { value: fallback, fallbackUsed: true }
+        typeof flagCheck !== "undefined" ? flagCheck : { value: result, fallbackUsed: true }
       );
       if (typeof flagCheck !== "undefined") {
         this.submitFlagCheckEvent(key, flagCheck, context);
@@ -952,14 +1042,14 @@ var Schematic = class {
       return result;
     } catch (error) {
       console.error("Unexpected error in checkFlag:", error);
-      const errorResult = {
-        flag: key,
-        value: fallback,
-        reason: "Unexpected error in flag check",
-        error: error instanceof Error ? error.message : String(error)
-      };
+      const errorResult = this.resolveFallbackCheckFlagReturn(
+        key,
+        fallback,
+        "Unexpected error in flag check",
+        error instanceof Error ? error.message : String(error)
+      );
       this.submitFlagCheckEvent(key, errorResult, context);
-      return fallback;
+      return errorResult.value;
     }
   }
   /**
@@ -1002,11 +1092,12 @@ var Schematic = class {
    */
   async fallbackToRest(key, context, fallback) {
     if (this.isOffline()) {
+      const resolvedFallback = this.resolveFallbackValue(key, fallback);
       this.debug(`fallbackToRest offline result: ${key}`, {
-        value: fallback,
+        value: resolvedFallback,
         offlineMode: true
       });
-      return fallback;
+      return resolvedFallback;
     }
     try {
       const requestUrl = `${this.apiUrl}/flags/${key}/check`;
@@ -1033,14 +1124,14 @@ var Schematic = class {
       return result.value;
     } catch (error) {
       console.error("REST API call failed, using fallback value:", error);
-      const errorResult = {
-        flag: key,
-        value: fallback,
-        reason: "API request failed (fallback)",
-        error: error instanceof Error ? error.message : String(error)
-      };
+      const errorResult = this.resolveFallbackCheckFlagReturn(
+        key,
+        fallback,
+        "API request failed (fallback)",
+        error instanceof Error ? error.message : String(error)
+      );
       this.submitFlagCheckEvent(key, errorResult, context);
-      return fallback;
+      return errorResult.value;
     }
   }
   /**
@@ -1257,11 +1348,53 @@ var Schematic = class {
       }
     }
   };
-  flushEventQueue = () => {
-    while (this.eventQueue.length > 0) {
-      const event = this.eventQueue.shift();
-      if (event) {
-        this.sendEvent(event);
+  startRetryTimer = () => {
+    if (this.retryTimer !== null) {
+      return;
+    }
+    this.retryTimer = setInterval(() => {
+      this.flushEventQueue().catch((error) => {
+        this.debug("Error in retry timer flush:", error);
+      });
+      if (this.eventQueue.length === 0) {
+        this.stopRetryTimer();
+      }
+    }, 5e3);
+    this.debug("Started retry timer");
+  };
+  stopRetryTimer = () => {
+    if (this.retryTimer !== null) {
+      clearInterval(this.retryTimer);
+      this.retryTimer = null;
+      this.debug("Stopped retry timer");
+    }
+  };
+  flushEventQueue = async () => {
+    if (this.eventQueue.length === 0) {
+      return;
+    }
+    const now = Date.now();
+    const readyEvents = [];
+    const notReadyEvents = [];
+    for (const event of this.eventQueue) {
+      if (event.next_retry_at === void 0 || event.next_retry_at <= now) {
+        readyEvents.push(event);
+      } else {
+        notReadyEvents.push(event);
+      }
+    }
+    if (readyEvents.length === 0) {
+      this.debug(`No events ready for retry yet (${notReadyEvents.length} still in backoff)`);
+      return;
+    }
+    this.debug(`Flushing event queue: ${readyEvents.length} ready, ${notReadyEvents.length} waiting`);
+    this.eventQueue = notReadyEvents;
+    for (const event of readyEvents) {
+      try {
+        await this.sendEvent(event);
+        this.debug(`Queued event sent successfully:`, event.type);
+      } catch (error) {
+        this.debug(`Failed to send queued event:`, error);
       }
     }
   };
@@ -1309,12 +1442,37 @@ var Schematic = class {
         },
         body: payload
       });
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
       this.debug(`event sent:`, {
         status: response.status,
         statusText: response.statusText
       });
     } catch (error) {
-      console.error("Error sending Schematic event: ", error);
+      const retryCount = (event.retry_count ?? 0) + 1;
+      if (retryCount <= this.maxEventRetries) {
+        this.debug(`Event failed to send (attempt ${retryCount}/${this.maxEventRetries}), queueing for retry:`, error);
+        const baseDelay = this.eventRetryInitialDelay * Math.pow(2, retryCount - 1);
+        const jitterDelay = Math.min(baseDelay, this.eventRetryMaxDelay);
+        const nextRetryAt = Date.now() + jitterDelay;
+        const retryEvent = {
+          ...event,
+          retry_count: retryCount,
+          next_retry_at: nextRetryAt
+        };
+        if (this.eventQueue.length < this.maxEventQueueSize) {
+          this.eventQueue.push(retryEvent);
+          this.debug(`Event queued for retry in ${jitterDelay}ms (${this.eventQueue.length}/${this.maxEventQueueSize})`);
+        } else {
+          this.debug(`Event queue full (${this.maxEventQueueSize}), dropping oldest event`);
+          this.eventQueue.shift();
+          this.eventQueue.push(retryEvent);
+        }
+        this.startRetryTimer();
+      } else {
+        this.debug(`Event failed permanently after ${this.maxEventRetries} attempts, dropping:`, error);
+      }
     }
     return Promise.resolve();
   };
@@ -1339,6 +1497,7 @@ var Schematic = class {
       clearTimeout(this.wsReconnectTimer);
       this.wsReconnectTimer = null;
     }
+    this.stopRetryTimer();
     if (this.conn) {
       try {
         const socket = await this.conn;
@@ -1386,16 +1545,15 @@ var Schematic = class {
    * Handle browser coming back online
    */
   handleNetworkOnline = () => {
-    if (this.context.company === void 0 && this.context.user === void 0) {
-      this.debug("No context set, skipping reconnection");
-      return;
-    }
+    this.debug("Network online, attempting reconnection and flushing queued events");
     this.wsReconnectAttempts = 0;
     if (this.wsReconnectTimer !== null) {
       clearTimeout(this.wsReconnectTimer);
       this.wsReconnectTimer = null;
     }
-    this.debug("Network online, reconnecting immediately");
+    this.flushEventQueue().catch((error) => {
+      this.debug("Error flushing event queue on network online:", error);
+    });
     this.attemptReconnect();
   };
   /**
@@ -1425,10 +1583,20 @@ var Schematic = class {
       try {
         this.conn = this.wsConnect();
         const socket = await this.conn;
+        this.debug(`Reconnection context check:`, {
+          hasCompany: this.context.company !== void 0,
+          hasUser: this.context.user !== void 0,
+          context: this.context
+        });
         if (this.context.company !== void 0 || this.context.user !== void 0) {
-          this.debug(`Reconnected, re-sending context`);
-          await this.wsSendMessage(socket, this.context);
+          this.debug(`Reconnected, force re-sending context`);
+          await this.wsSendContextAfterReconnection(socket, this.context);
+        } else {
+          this.debug(`No context to re-send after reconnection - websocket ready for new context`);
         }
+        this.flushEventQueue().catch((error) => {
+          this.debug("Error flushing event queue after websocket reconnection:", error);
+        });
         this.debug(`Reconnection successful`);
       } catch (error) {
         this.debug(`Reconnection attempt failed:`, error);
@@ -1489,6 +1657,61 @@ var Schematic = class {
       };
     });
   };
+  // Send a message on the websocket after reconnection, forcing the send even if context appears unchanged
+  // because the server has lost all state and needs the initial context
+  wsSendContextAfterReconnection = (socket, context) => {
+    if (this.isOffline()) {
+      this.debug("wsSendContextAfterReconnection: skipped (offline mode)");
+      this.setIsPending(false);
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      this.debug(`WebSocket force sending context after reconnection:`, context);
+      this.context = context;
+      const sendMessage = () => {
+        let resolved = false;
+        const messageHandler = (event) => {
+          const message = JSON.parse(event.data);
+          this.debug(`WebSocket message received after reconnection:`, message);
+          if (!(contextString(context) in this.checks)) {
+            this.checks[contextString(context)] = {};
+          }
+          (message.flags ?? []).forEach((flag) => {
+            const flagCheck = CheckFlagReturnFromJSON(flag);
+            const contextStr = contextString(context);
+            if (this.checks[contextStr] === void 0) {
+              this.checks[contextStr] = {};
+            }
+            this.checks[contextStr][flagCheck.flag] = flagCheck;
+          });
+          this.useWebSocket = true;
+          socket.removeEventListener("message", messageHandler);
+          if (!resolved) {
+            resolved = true;
+            resolve(this.setIsPending(false));
+          }
+        };
+        socket.addEventListener("message", messageHandler);
+        const clientVersion = this.additionalHeaders["X-Schematic-Client-Version"] ?? `schematic-js@${version}`;
+        const messagePayload = {
+          apiKey: this.apiKey,
+          clientVersion,
+          data: context
+        };
+        this.debug(`WebSocket sending forced message after reconnection:`, messagePayload);
+        socket.send(JSON.stringify(messagePayload));
+      };
+      if (socket.readyState === WebSocket.OPEN) {
+        this.debug(`WebSocket already open, sending forced message after reconnection`);
+        sendMessage();
+      } else {
+        socket.addEventListener("open", () => {
+          this.debug(`WebSocket opened, sending forced message after reconnection`);
+          sendMessage();
+        });
+      }
+    });
+  };
   // Send a message on the websocket indicating interest in a particular evaluation context
   // and wait for the initial set of flag values to be returned
   wsSendMessage = (socket, context) => {
@@ -1677,7 +1900,7 @@ var notifyFlagValueListener = (listener, value) => {
 import React, { createContext, useEffect, useMemo, useRef } from "react";
 
 // src/version.ts
-var version2 = "1.2.7";
+var version2 = "1.2.9";
 
 // src/context/schematic.tsx
 import { jsx } from "react/jsx-runtime";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@schematichq/schematic-react",
-  "version": "1.2.7",
+  "version": "1.2.9",
   "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.7"
+    "@schematichq/schematic-js": "^1.2.9"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
@@ -39,7 +39,7 @@
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.0",
-    "@types/react": "^19.2.3",
+    "@types/react": "^19.2.6",
     "@vitest/browser": "^4.0.8",
     "esbuild": "^0.27.0",
     "eslint": "^9.39.1",
@@ -54,7 +54,7 @@
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.4",
+    "typescript-eslint": "^8.47.0",
     "vitest": "^4.0.8"
   },
   "peerDependencies": {