fix(core): Fix standalone mode and runApplication reset for appLoaded()

Fix two bugs identified in the Cursor Bugbot review:

1. Standalone mode: appLoaded() loses manual timestamp (High)
   When auto-capture from ReactNativeProfiler runs first in standalone
   mode, it sends the transaction and sets appStartDataFlushed = true.
   A subsequent appLoaded() call would find the flag set and silently
   skip re-sending. Fix: add resetAppStartDataFlushed() method on the
   AppStartIntegration type, called by _appLoaded() before invoking
   captureStandaloneAppStart(). This allows the standalone transaction
   to be re-sent with the correct manual timestamp.

2. isAppLoadedManuallyInvoked not reset on runApplication (Medium)
   The onRunApplication callback resets appStartDataFlushed and span
   tracking state for subsequent app starts (e.g. Android activity
   recreation), but did not reset isAppLoadedManuallyInvoked. After
   the first appLoaded() call, all subsequent app starts would have
   auto-capture permanently blocked. Fix: reset the flag alongside
   the other state in the onRunApplication callback.

Adds two tests: standalone override after auto-capture, and flag
reset allowing auto-capture on subsequent app starts.

Author: alwx

packages/core/src/js/tracing/integrations/appStart.ts

@@ -37,6 +37,7 @@ const INTEGRATION_NAME = 'AppStart';
 
 export type AppStartIntegration = Integration & {
   captureStandaloneAppStart: () => Promise<void>;
+  resetAppStartDataFlushed: () => void;
 };
 
 /**
@@ -108,7 +109,14 @@ export async function _appLoaded(): Promise<void> {
   isRecordedAppStartEndTimestampMsManual = true;
 
   await fetchAndUpdateEndFrames();
-  await client.getIntegrationByName<AppStartIntegration>(INTEGRATION_NAME)?.captureStandaloneAppStart();
+
+  const integration = client.getIntegrationByName<AppStartIntegration>(INTEGRATION_NAME);
+  if (integration) {
+    // In standalone mode, auto-capture may have already flushed the transaction.
+    // Reset the flag so captureStandaloneAppStart can re-send with the manual timestamp.
+    integration.resetAppStartDataFlushed();
+    await integration.captureStandaloneAppStart();
+  }
 }
 
 /**
@@ -294,6 +302,7 @@ export const appStartIntegration = ({
         appStartDataFlushed = false;
         firstStartedActiveRootSpanId = undefined;
         firstStartedActiveRootSpan = undefined;
+        isAppLoadedManuallyInvoked = false;
       } else {
         debug.log(
           '[AppStartIntegration] Waiting for initial app start was flush, before updating based on runApplication call.',
@@ -604,12 +613,17 @@ export const appStartIntegration = ({
     );
   }
 
+  const resetAppStartDataFlushed = (): void => {
+    appStartDataFlushed = false;
+  };
+
   return {
     name: INTEGRATION_NAME,
     setup,
     afterAllSetup,
     processEvent,
     captureStandaloneAppStart,
+    resetAppStartDataFlushed,
     setFirstStartedActiveRootSpanId,
   } as AppStartIntegration;
 };

packages/core/test/tracing/integrations/appStart.test.ts

@@ -1243,6 +1243,96 @@ describe('appLoaded() standalone mode', () => {
     expect(appStartSpan?.start_timestamp).toBeCloseTo(appStartTimeMilliseconds / 1000, 1);
     expect(appStartSpan?.origin).toBe(SPAN_ORIGIN_MANUAL_APP_START);
   });
+
+  it('overrides already-flushed standalone transaction when appLoaded() is called after auto-capture', async () => {
+    getCurrentScope().clear();
+    getIsolationScope().clear();
+    getGlobalScope().clear();
+
+    const [, appStartTimeMilliseconds] = mockAppStart({ cold: true });
+
+    const integration = appStartIntegration({ standalone: true }) as AppStartIntegrationTest;
+    const standaloneClient = new TestClient({
+      ...getDefaultTestClientOptions(),
+      enableAppStartTracking: true,
+      tracesSampleRate: 1.0,
+    });
+    setCurrentClient(standaloneClient);
+    integration.setup(standaloneClient);
+    standaloneClient.addIntegration(integration);
+
+    // Simulate auto-capture from ReactNativeProfiler (componentDidMount)
+    const autoTimeSeconds = Date.now() / 1000;
+    mockFunction(timestampInSeconds).mockReturnValue(autoTimeSeconds);
+    await _captureAppStart({ isManual: false });
+    await new Promise(resolve => setTimeout(resolve, 0));
+
+    // Auto-capture should have sent the standalone transaction
+    expect(standaloneClient.eventQueue.length).toBe(1);
+    const autoEvent = standaloneClient.eventQueue[0];
+    const autoSpan = autoEvent?.spans?.find(s => s.op === APP_START_COLD_OP);
+    expect(autoSpan?.timestamp).toBeCloseTo(autoTimeSeconds, 1);
+
+    // Now call appLoaded() with a later timestamp
+    const manualTimeSeconds = autoTimeSeconds + 2;
+    mockFunction(timestampInSeconds).mockReturnValue(manualTimeSeconds);
+    await _appLoaded();
+    await new Promise(resolve => setTimeout(resolve, 0));
+
+    // appLoaded() should have sent a second standalone transaction with the manual timestamp
+    expect(standaloneClient.eventQueue.length).toBe(2);
+    const manualEvent = standaloneClient.eventQueue[1];
+    const manualSpan = manualEvent?.spans?.find(s => s.op === APP_START_COLD_OP);
+    expect(manualSpan).toBeDefined();
+    expect(manualSpan?.timestamp).toBeCloseTo(manualTimeSeconds, 1);
+    expect(manualSpan?.start_timestamp).toBeCloseTo(appStartTimeMilliseconds / 1000, 1);
+    expect(manualSpan?.origin).toBe(SPAN_ORIGIN_MANUAL_APP_START);
+  });
+
+  it('allows auto-capture again after isAppLoadedManuallyInvoked is reset', async () => {
+    getCurrentScope().clear();
+    getIsolationScope().clear();
+    getGlobalScope().clear();
+
+    mockAppStart({ cold: true });
+
+    const integration = appStartIntegration({ standalone: true }) as AppStartIntegrationTest;
+    const standaloneClient = new TestClient({
+      ...getDefaultTestClientOptions(),
+      enableAppStartTracking: true,
+      tracesSampleRate: 1.0,
+    });
+    setCurrentClient(standaloneClient);
+    integration.setup(standaloneClient);
+    standaloneClient.addIntegration(integration);
+
+    // First app start: call appLoaded()
+    const firstTimeSeconds = Date.now() / 1000;
+    mockFunction(timestampInSeconds).mockReturnValue(firstTimeSeconds);
+    await _appLoaded();
+    await new Promise(resolve => setTimeout(resolve, 0));
+    expect(standaloneClient.eventQueue.length).toBe(1);
+
+    // Verify auto-capture is blocked while flag is set
+    const logSpy = jest.spyOn(debug, 'log');
+    await _captureAppStart({ isManual: false });
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping auto app start capture'));
+
+    // Simulate what onRunApplication does: reset flags for a new app start
+    _clearAppStartEndData();
+    mockAppStart({ cold: true });
+
+    // Now auto-capture should work again
+    logSpy.mockClear();
+    const autoTimeSeconds = Date.now() / 1000 + 1;
+    mockFunction(timestampInSeconds).mockReturnValue(autoTimeSeconds);
+    await _captureAppStart({ isManual: false });
+
+    const skippedCalls = logSpy.mock.calls.filter(
+      call => typeof call[0] === 'string' && call[0].includes('Skipping auto app start capture'),
+    );
+    expect(skippedCalls.length).toBe(0);
+  });
 });
 
 describe('Frame Data Integration', () => {