fix: prevent event loss during initialization by setting isReady before onReady

Fixed a race condition where events tracked during the onReady() processing
were incorrectly categorized as pending and never sent to Segment.

The bug occurred when:
1. App starts tracking events before initialization
2. During init, onReady() begins processing pending events (takes seconds)
3. New events arrive while onReady() is still running
4. These events check isReady (still false) and get saved as "pending"
5. Since onReady() already ran, these new pending events are never processed

The fix simply swaps two lines to set isReady=true BEFORE calling onReady(),
ensuring any events that arrive during processing go directly to the queue.

Added tests to verify the initialization order and prevent regression.

Author: bytesoverflow

packages/core/src/__tests__/analytics.test.ts

@@ -249,4 +249,85 @@ describe('SegmentClient', () => {
       expect(client.getFlushPolicies().length).toBe(policies.length);
     });
   });
+
+  describe('Initialization order - race condition fix', () => {
+    /*jshint -W069 */
+    /* eslint-disable dot-notation */
+    it('sets isReady to true before executing onReady to prevent events being lost', async () => {
+      // This test verifies that the race condition fix works:
+      // isReady is set to true BEFORE onReady() executes,
+      // so events tracked during onReady() go directly to the queue
+      // instead of being incorrectly saved as pending events.
+
+      client = new SegmentClient(clientArgs);
+
+      // Track the value of isReady when onReady is called
+      let isReadyValueInOnReady: boolean | undefined;
+
+      // Mock onReady to capture the isReady state
+      const originalOnReady = client['onReady'].bind(client);
+      client['onReady'] = jest.fn(async () => {
+        // Capture isReady value at the start of onReady
+        isReadyValueInOnReady = client['isReady'].value;
+        // Call the original onReady
+        return originalOnReady();
+      });
+
+      // Initialize the client
+      await client.init();
+
+      // Verify that isReady was true when onReady was called
+      // This is the key fix - isReady is set BEFORE onReady runs
+      expect(isReadyValueInOnReady).toBe(true);
+
+      // Verify onReady was called
+      expect(client['onReady']).toHaveBeenCalledTimes(1);
+    });
+
+    it('ensures correct operation order: isReady -> onReady -> processing', async () => {
+      client = new SegmentClient(clientArgs);
+
+      // Track the order of operations
+      const operationOrder: string[] = [];
+
+      // Mock isReady setter
+      const isReadyDescriptor = Object.getOwnPropertyDescriptor(
+        client['isReady'],
+        'value'
+      );
+      Object.defineProperty(client['isReady'], 'value', {
+        ...isReadyDescriptor,
+        set: function (value: boolean) {
+          if (value === true) {
+            operationOrder.push('isReady-set-true');
+          }
+          isReadyDescriptor?.set?.call(this, value);
+        },
+      });
+
+      // Mock onReady to track when it's called
+      const originalOnReady = client['onReady'].bind(client);
+      client['onReady'] = jest.fn(async () => {
+        operationOrder.push('onReady-start');
+        await originalOnReady();
+        operationOrder.push('onReady-end');
+      });
+
+      // Initialize the client
+      await client.init();
+
+      // Verify the correct order: isReady is set true BEFORE onReady starts
+      // The expected order should be:
+      // 1. isReady-set-true
+      // 2. onReady-start
+      // 3. onReady-end
+      expect(operationOrder).toEqual([
+        'isReady-set-true',
+        'onReady-start',
+        'onReady-end',
+      ]);
+    });
+  });
+  /*jshint +W069 */
+  /* eslint-enable dot-notation */
 });

packages/core/src/analytics.ts

@@ -308,8 +308,9 @@ export class SegmentClient {
         this.trackDeepLinks(),
       ]);
 
-      await this.onReady();
+      // Set ready BEFORE processing pending events to prevent race condition
       this.isReady.value = true;
+      await this.onReady();
     } catch (error) {
       this.reportInternalError(
         new SegmentError(